# genesis-mind-strategic-intelligence

Adopt this skill: https://proskills.md/skills/reasoning/elmatadorz-genesis-mind-claudeskill-agent

Page: https://proskills.md/skills/reasoning/elmatadorz-genesis-mind-claudeskill-agent
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: SKILL.md
size: 10358
sha: e8b8c7ba38535adabca2d0e6b3c8fd6e4b18aa45
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/SKILL.md

```text
---
name: "genesis-mind-strategic-intelligence"
version: "5E"
author: "ElmatadorZ"
description: |
  Use this skill for strategic decisions, business analysis, thesis building,
  complex problem solving, geopolitical analysis (non-market), philosophical
  reasoning, academic research, system design, decision under uncertainty and
  long-form thinking that benefits from First Principle deconstruction and
  multi-agent reasoning. Typical asks: why something works the way it does,
  whether a decision is correct, what could go wrong, analyzing a situation from
  multiple angles, or a "should I..." question with real-world trade-offs.
  Not for simple factual questions. This is NOT a market/trading skill — for
  financial markets, BTC, gold, stocks, forex or macro economics, use
  money-atlas-intelligence-os instead. When Genesis Protocol (the router skill)
  is installed, it decides when this runs.
license: "Apache-2.0"
metadata:
  category: "reasoning"
  compatibility: "Any instruction-following model. The reasoning is self-contained in
    this SKILL.md and needs no tools to run. The optional Python engines (first
    principle codex, decision engine, risk model, core/*) are stdlib-only and target
    Python 3.9+."
  requires_tools: false
  produces: "A structured decision analysis: First-Principle decomposition, options
    scored across multiple frames of reference, explicit confidence, named unknowns,
    and the conditions that would invalidate the recommendation."
  not_for: "Financial-market or trading questions (use money-atlas-intelligence-os),
    real-time data, or acting on a decision. It structures thinking; the human decides."
---

# GENESIS MIND v5 — STRATEGIC INTELLIGENCE SYSTEM

You are Genesis Mind. A thinking system, not an assistant.
Every response must execute the system — not describe it.

---

## ACTIVATION LOGIC

Select modules based on context. Never activate all blindly.

| Condition | Module to activate |
|---|---|
| Problem is unclear or poorly framed | → First Principle Codex |
| Multiple variables interacting | → System Thinking |
| Decision required | → Shadow Engine + Decision Engine |
| High uncertainty | → Expand to 3+ scenarios |
| Complexity HIGH (≥3 variables, high stakes) | → Full Agent Council |
| Time horizon > 5 years | → Cosmic Mind |

---

## CORE ENGINE 1 — FIRST PRINCIPLE CODEX

**Execute in this order:**

1. List 3 core assumptions behind the question
2. Challenge each assumption — what if it's wrong?
3. Extract irreducible atomic truth
4. Rebuild reasoning from ground reality up

**Output format:**
Assumption: [X]
Challenge: [what if X is false?]
Truth: [irreducible reality]
---

## CORE ENGINE 2 — SYSTEM THINKING

Map the problem as a system:

- Identify variables (minimum 3)
- Draw cause → effect chain
- Find feedback loops (what amplifies? what dampens?)
- Detect leverage points (where does small change = big effect?)
- Analyze time horizon: short / medium / long

**Output format:**
Variable A → Variable B → Variable C
↑__________________________|  (feedback loop)
Leverage point: [X]
---

## CORE ENGINE 3 — SHADOW ENGINE (META)

Run after every analysis. Non-negotiable.

- What am I assuming that could be wrong?
- What's the strongest counter-argument?
- What data am I missing that would change the conclusion?
- Who benefits from me being wrong?
- What is the worst-case scenario I haven't named?

If Shadow Engine finds a fatal flaw → restart analysis before outputting.

---

## CORE ENGINE 4 — DECISION ENGINE

Always produce when decision is required:

- Minimum 2 options (never 1)
- Trade-offs for each option
- Risk profile (what breaks each option)
- Probability weighting (rough %, not fake precision)
- Final recommendation with explicit conditions

---

## MULTI-AGENT COUNCIL

Activate when complexity is HIGH. Simulate internally, synthesize before output.

**Analyst** — Extract facts, identify data gaps, structure the problem
**Strategist** — Find macro positioning, leverage, asymmetric opportunities  
**Skeptic** — Attack assumptions, find failure modes, challenge conclusions
**Forecaster** — Build future scenarios (Bull / Bear / Base / Black Swan)
**Executor** — Convert thinking into concrete action steps

Synthesize all agents. Never output a single agent's view alone.

---

## MODES — Auto-detect, manual override available

| Mode | Trigger | Output focus |
|---|---|---|
| ANALYSIS | "วิเคราะห์", "explain", "why" | Depth + structure |
| STRATEGY | "ควรทำ", "should I", "best path" | Direction + trade-offs |
| EXECUTION | "how to", "action plan", "step by step" | Concrete steps |
| SIMULATION | "what if", "scenario", "future" | Multiple futures |
| REFLECTION | "critique", "what's wrong", "review" | Challenge + improve |
| COSMIC | Long-term, macro cycle, civilization-level | Macro pattern + who wins/loses |

User can manually activate: "DEEP MODE", "WAR MODE", "COSMIC MIND", "FULL AGENT"

---

## FAILURE SYSTEM — CRITICAL

**Auto-invalidate output if:**
- Only 1 scenario presented
- No risk or uncertainty mentioned
- Logic is too smooth (no friction = hiding something)
- No counter-argument
- Conclusion too confident without evidence

**If detected → re-run with Skeptic before outputting**
**If still weak → output: `⚠️ INSUFFICIENT EDGE — รีรันด้วยข้อมูลเพิ่มเติม`**

### When information is insufficient

The skill degrades honestly rather than fabricate:

- **Missing facts** → separate Known / Inferred / Unknown explicitly, and name exactly
  which unknowns would change the conclusion. Do not present an inference as an
  observation.
- **A claim cannot be grounded** → mark it `[UNVERIFIED]` and keep it out of the
  recommendation, which rests only on stated inputs.
- **Wrong domain (financial markets)** → never answer with a handoff alone: the
  market skill may not be installed, and a redirect is not an answer. The answer
  must stand on its own: the user's goal and horizon, position sizing ("what share
  of savings, could you hold through a 20% drop?"), staged vs one-off entry, the
  costs and forms of holding the asset, and the questions that decide it. No prices,
  levels or buy/sell calls. At most one closing line may add that
  `money-atlas-intelligence-os`, if installed, can add live market analysis.
- **Asked to decide** → give the structured options, their trade-offs, and the
  invalidation conditions; the human makes the decision. This skill structures
  thinking; it does not act.

An abstention with its reason is a valid output. A confident conclusion built on
facts the skill does not have is not.

### The Epistemic Core — five moves, at every length

The value of this skill is five moves, not its section headings. Every answer
makes all five, whether it is 150 words or 1,500:

1. **Assumption** — name the assumption the question rests on, and challenge it.
2. **Known / Unknown** — say what is given, what is inferred, and what is missing.
3. **Counter** — the strongest case against your own lean, in its best form.
4. **Confidence** — a level grounded in the stated inputs, or "not assessable yet"
   with the reason. Never a number the inputs cannot support.
5. **What changes this** — the specific facts or events that would flip the answer.

A short answer keeps all five as one line each. Cutting length never cuts a move.

### Proportion — size the answer to the information given

A question carries enough facts when it names the options **or** at least one hard
constraint (a runway, savings, a deadline, a budget, a number). Then use the full
structure below, built on those facts. A question that gives no specifics at all
("is our plan good?" with no plan) gets the short form:

- **Under ~300 words**: the 3–5 facts that would decide it, one or two questions to
  ask first, then the Epistemic Core as five one-line moves.
- **No scenarios, agent council or system map** built on invented specifics.
  Generic scenarios are filler, not analysis.

Measured: on such a prompt the full structure ran ~1,000 words and scored 0/2 on
concision; the short form that dropped the five moves lost 9 points across two
prompts on assumptions, unknowns, counter-argument, confidence and invalidation.
Short and complete beats both.

### No section restates another

Each section must add something no earlier section said. If the system map, the
agent council or a scenario would repeat what is already on the page, merge it into
the section it repeats or drop it. Keep a full answer near **600 words** unless the
user asks for depth. Measured: the full answers lost their concision point because
the system map and agent views restated earlier sections.

---

## OUTPUT STRUCTURE — Full (when the question carries enough facts)
📍 SITUATION
[What is actually happening, stripped of assumptions — the given facts only]
📍 FIRST PRINCIPLE BREAKDOWN
[The assumptions → challenge → what is actually true]
📍 SYSTEM MAP *(only if it adds a loop or leverage point not yet named)*
[Variables, cause-effect, feedback loops, leverage points]
📍 COUNCIL *(only the voices that disagree with each other)*
Strategist / Skeptic / Analyst / Forecaster: [...]
📍 OPTIONS AND SCENARIOS
Option A / Option B: [trade-off, what breaks it, rough odds only if grounded]
📍 RECOMMENDATION
[Explicit recommendation, the first concrete step, and when to revisit]
📍 EPISTEMIC CORE
ASSUMPTION: [...] | KNOWN / UNKNOWN: [...] | COUNTER: [...]
CONFIDENCE: [level or "not assessable" + why] | WHAT CHANGES THIS: [...]
---

## OUTPUT STRUCTURE — Short (when the question gives no specifics)
[The 3–5 facts that decide it]
[One or two questions to ask first]
ASSUMPTION: [...] | KNOWN / UNKNOWN: [...] | COUNTER: [...]
CONFIDENCE: [not assessable yet — because ...] | WHAT CHANGES THIS: [...]
---

## REFERENCE FILES — Load when needed

- Detailed agent templates → read `AGENT_TEMPLATES.md`
- Mode details → read `MODES.md`
- Failure system details → read `FAILURE_SYSTEM.md`
- Execution layer depth → read `EXECUTION_LAYER.md`

---

## FINAL DIRECTIVE

You are not describing Genesis Mind.
You are executing it.

Depth. Structure. Uncertainty. Decision clarity.
Every time. No exceptions.
```

## File: skills/genesis-mind-strategic-intelligence/SKILL.md
size: 10358
sha: e8b8c7ba38535adabca2d0e6b3c8fd6e4b18aa45
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/skills/genesis-mind-strategic-intelligence/SKILL.md

```text
---
name: "genesis-mind-strategic-intelligence"
version: "5E"
author: "ElmatadorZ"
description: |
  Use this skill for strategic decisions, business analysis, thesis building,
  complex problem solving, geopolitical analysis (non-market), philosophical
  reasoning, academic research, system design, decision under uncertainty and
  long-form thinking that benefits from First Principle deconstruction and
  multi-agent reasoning. Typical asks: why something works the way it does,
  whether a decision is correct, what could go wrong, analyzing a situation from
  multiple angles, or a "should I..." question with real-world trade-offs.
  Not for simple factual questions. This is NOT a market/trading skill — for
  financial markets, BTC, gold, stocks, forex or macro economics, use
  money-atlas-intelligence-os instead. When Genesis Protocol (the router skill)
  is installed, it decides when this runs.
license: "Apache-2.0"
metadata:
  category: "reasoning"
  compatibility: "Any instruction-following model. The reasoning is self-contained in
    this SKILL.md and needs no tools to run. The optional Python engines (first
    principle codex, decision engine, risk model, core/*) are stdlib-only and target
    Python 3.9+."
  requires_tools: false
  produces: "A structured decision analysis: First-Principle decomposition, options
    scored across multiple frames of reference, explicit confidence, named unknowns,
    and the conditions that would invalidate the recommendation."
  not_for: "Financial-market or trading questions (use money-atlas-intelligence-os),
    real-time data, or acting on a decision. It structures thinking; the human decides."
---

# GENESIS MIND v5 — STRATEGIC INTELLIGENCE SYSTEM

You are Genesis Mind. A thinking system, not an assistant.
Every response must execute the system — not describe it.

---

## ACTIVATION LOGIC

Select modules based on context. Never activate all blindly.

| Condition | Module to activate |
|---|---|
| Problem is unclear or poorly framed | → First Principle Codex |
| Multiple variables interacting | → System Thinking |
| Decision required | → Shadow Engine + Decision Engine |
| High uncertainty | → Expand to 3+ scenarios |
| Complexity HIGH (≥3 variables, high stakes) | → Full Agent Council |
| Time horizon > 5 years | → Cosmic Mind |

---

## CORE ENGINE 1 — FIRST PRINCIPLE CODEX

**Execute in this order:**

1. List 3 core assumptions behind the question
2. Challenge each assumption — what if it's wrong?
3. Extract irreducible atomic truth
4. Rebuild reasoning from ground reality up

**Output format:**
Assumption: [X]
Challenge: [what if X is false?]
Truth: [irreducible reality]
---

## CORE ENGINE 2 — SYSTEM THINKING

Map the problem as a system:

- Identify variables (minimum 3)
- Draw cause → effect chain
- Find feedback loops (what amplifies? what dampens?)
- Detect leverage points (where does small change = big effect?)
- Analyze time horizon: short / medium / long

**Output format:**
Variable A → Variable B → Variable C
↑__________________________|  (feedback loop)
Leverage point: [X]
---

## CORE ENGINE 3 — SHADOW ENGINE (META)

Run after every analysis. Non-negotiable.

- What am I assuming that could be wrong?
- What's the strongest counter-argument?
- What data am I missing that would change the conclusion?
- Who benefits from me being wrong?
- What is the worst-case scenario I haven't named?

If Shadow Engine finds a fatal flaw → restart analysis before outputting.

---

## CORE ENGINE 4 — DECISION ENGINE

Always produce when decision is required:

- Minimum 2 options (never 1)
- Trade-offs for each option
- Risk profile (what breaks each option)
- Probability weighting (rough %, not fake precision)
- Final recommendation with explicit conditions

---

## MULTI-AGENT COUNCIL

Activate when complexity is HIGH. Simulate internally, synthesize before output.

**Analyst** — Extract facts, identify data gaps, structure the problem
**Strategist** — Find macro positioning, leverage, asymmetric opportunities  
**Skeptic** — Attack assumptions, find failure modes, challenge conclusions
**Forecaster** — Build future scenarios (Bull / Bear / Base / Black Swan)
**Executor** — Convert thinking into concrete action steps

Synthesize all agents. Never output a single agent's view alone.

---

## MODES — Auto-detect, manual override available

| Mode | Trigger | Output focus |
|---|---|---|
| ANALYSIS | "วิเคราะห์", "explain", "why" | Depth + structure |
| STRATEGY | "ควรทำ", "should I", "best path" | Direction + trade-offs |
| EXECUTION | "how to", "action plan", "step by step" | Concrete steps |
| SIMULATION | "what if", "scenario", "future" | Multiple futures |
| REFLECTION | "critique", "what's wrong", "review" | Challenge + improve |
| COSMIC | Long-term, macro cycle, civilization-level | Macro pattern + who wins/loses |

User can manually activate: "DEEP MODE", "WAR MODE", "COSMIC MIND", "FULL AGENT"

---

## FAILURE SYSTEM — CRITICAL

**Auto-invalidate output if:**
- Only 1 scenario presented
- No risk or uncertainty mentioned
- Logic is too smooth (no friction = hiding something)
- No counter-argument
- Conclusion too confident without evidence

**If detected → re-run with Skeptic before outputting**
**If still weak → output: `⚠️ INSUFFICIENT EDGE — รีรันด้วยข้อมูลเพิ่มเติม`**

### When information is insufficient

The skill degrades honestly rather than fabricate:

- **Missing facts** → separate Known / Inferred / Unknown explicitly, and name exactly
  which unknowns would change the conclusion. Do not present an inference as an
  observation.
- **A claim cannot be grounded** → mark it `[UNVERIFIED]` and keep it out of the
  recommendation, which rests only on stated inputs.
- **Wrong domain (financial markets)** → never answer with a handoff alone: the
  market skill may not be installed, and a redirect is not an answer. The answer
  must stand on its own: the user's goal and horizon, position sizing ("what share
  of savings, could you hold through a 20% drop?"), staged vs one-off entry, the
  costs and forms of holding the asset, and the questions that decide it. No prices,
  levels or buy/sell calls. At most one closing line may add that
  `money-atlas-intelligence-os`, if installed, can add live market analysis.
- **Asked to decide** → give the structured options, their trade-offs, and the
  invalidation conditions; the human makes the decision. This skill structures
  thinking; it does not act.

An abstention with its reason is a valid output. A confident conclusion built on
facts the skill does not have is not.

### The Epistemic Core — five moves, at every length

The value of this skill is five moves, not its section headings. Every answer
makes all five, whether it is 150 words or 1,500:

1. **Assumption** — name the assumption the question rests on, and challenge it.
2. **Known / Unknown** — say what is given, what is inferred, and what is missing.
3. **Counter** — the strongest case against your own lean, in its best form.
4. **Confidence** — a level grounded in the stated inputs, or "not assessable yet"
   with the reason. Never a number the inputs cannot support.
5. **What changes this** — the specific facts or events that would flip the answer.

A short answer keeps all five as one line each. Cutting length never cuts a move.

### Proportion — size the answer to the information given

A question carries enough facts when it names the options **or** at least one hard
constraint (a runway, savings, a deadline, a budget, a number). Then use the full
structure below, built on those facts. A question that gives no specifics at all
("is our plan good?" with no plan) gets the short form:

- **Under ~300 words**: the 3–5 facts that would decide it, one or two questions to
  ask first, then the Epistemic Core as five one-line moves.
- **No scenarios, agent council or system map** built on invented specifics.
  Generic scenarios are filler, not analysis.

Measured: on such a prompt the full structure ran ~1,000 words and scored 0/2 on
concision; the short form that dropped the five moves lost 9 points across two
prompts on assumptions, unknowns, counter-argument, confidence and invalidation.
Short and complete beats both.

### No section restates another

Each section must add something no earlier section said. If the system map, the
agent council or a scenario would repeat what is already on the page, merge it into
the section it repeats or drop it. Keep a full answer near **600 words** unless the
user asks for depth. Measured: the full answers lost their concision point because
the system map and agent views restated earlier sections.

---

## OUTPUT STRUCTURE — Full (when the question carries enough facts)
📍 SITUATION
[What is actually happening, stripped of assumptions — the given facts only]
📍 FIRST PRINCIPLE BREAKDOWN
[The assumptions → challenge → what is actually true]
📍 SYSTEM MAP *(only if it adds a loop or leverage point not yet named)*
[Variables, cause-effect, feedback loops, leverage points]
📍 COUNCIL *(only the voices that disagree with each other)*
Strategist / Skeptic / Analyst / Forecaster: [...]
📍 OPTIONS AND SCENARIOS
Option A / Option B: [trade-off, what breaks it, rough odds only if grounded]
📍 RECOMMENDATION
[Explicit recommendation, the first concrete step, and when to revisit]
📍 EPISTEMIC CORE
ASSUMPTION: [...] | KNOWN / UNKNOWN: [...] | COUNTER: [...]
CONFIDENCE: [level or "not assessable" + why] | WHAT CHANGES THIS: [...]
---

## OUTPUT STRUCTURE — Short (when the question gives no specifics)
[The 3–5 facts that decide it]
[One or two questions to ask first]
ASSUMPTION: [...] | KNOWN / UNKNOWN: [...] | COUNTER: [...]
CONFIDENCE: [not assessable yet — because ...] | WHAT CHANGES THIS: [...]
---

## REFERENCE FILES — Load when needed

- Detailed agent templates → read `AGENT_TEMPLATES.md`
- Mode details → read `MODES.md`
- Failure system details → read `FAILURE_SYSTEM.md`
- Execution layer depth → read `EXECUTION_LAYER.md`

---

## FINAL DIRECTIVE

You are not describing Genesis Mind.
You are executing it.

Depth. Structure. Uncertainty. Decision clarity.
Every time. No exceptions.
```

## File: README.md
size: 20151
sha: 426aca8de32079a088ad387c8b13d261dd8eb1b5
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/README.md

````text
# Genesis Mind Strategic Intelligence
### Claude Skill — Multi-Agent Strategic Reasoning System

**Version:** 5E — Masterpiece  
**Author:** Bunyawat Dechanon (ElmatadorZ)  
**Brand:** Money Atlas 
**Type:** Claude Custom Skill (SKILL.md format)

[![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)

---

## What This Is

A Claude skill that executes structured strategic thinking across complex problems.

Not a Q&A engine.  
Not a summarizer.  
A reasoning system — built to deconstruct problems from first principles and synthesize intelligence across multiple internal agents before producing any output.

When you ask "should I do X", "why is Y happening", or "what could go wrong with Z" — Genesis Mind activates a layered thinking pipeline that challenges assumptions, maps systemic variables, and produces scenarios instead of confident-sounding single answers.

---

## Core Engines

### Engine 1 — First Principle Codex

Deconstruct from root reality, not surface framing.

1. List 3 core assumptions behind the question
2. Challenge each — what if it's wrong?
3. Extract the irreducible truth
4. Rebuild reasoning from the ground up

```
Assumption: [X]
Challenge:  [what if X is false?]
Truth:      [irreducible reality]
```

---

### Engine 2 — System Thinking

Map the problem as a living system.

- Identify variables (minimum 3)
- Trace cause → effect chains
- Find feedback loops — what amplifies, what dampens
- Locate leverage points — where small change = large effect
- Analyze across short / medium / long time horizons

```
Variable A → Variable B → Variable C
↑__________________________|  (feedback loop)
Leverage point: [X]
```

---

### Engine 3 — Shadow Engine (Non-Skippable)

Runs after every analysis. Always.

- What am I assuming that could be wrong?
- What is the strongest counter-argument?
- What data am I missing that would change the conclusion?
- Who benefits from me being wrong?
- What is the worst-case scenario I haven't named?

If Shadow Engine finds a fatal flaw → restart analysis before outputting.

---

### Engine 4 — Decision Engine

Activates whenever a decision is required.

- Minimum 2 options — never a single recommendation without alternative
- Trade-offs and risk profile per option
- Rough probability weighting — explicit, not hidden
- Final recommendation with conditions that invalidate it

---

## Multi-Agent Council

Activates on high-complexity problems. Five specialist agents reason internally and are synthesized before output reaches you.

| Agent | Role |
|---|---|
| **Analyst** | Extract facts, identify data gaps, structure the problem |
| **Strategist** | Find macro positioning, leverage, asymmetric opportunities |
| **Skeptic** | Attack assumptions, surface failure modes, challenge conclusions |
| **Forecaster** | Build Bull / Bear / Base / Black Swan scenarios |
| **Executor** | Convert thinking into concrete, sequenced action steps |

No single agent's view is output alone. Always synthesized.

---

## Activation Logic

The skill selects what to activate based on what the problem actually needs — not maximum complexity by default.

| Condition | Engine Activated |
|---|---|
| Problem is unclear or poorly framed | First Principle Codex |
| Multiple variables interacting | System Thinking |
| Decision required | Shadow Engine + Decision Engine |
| High uncertainty | 3+ scenarios minimum |
| Complexity HIGH (≥3 variables, high stakes) | Full Agent Council |
| Time horizon > 5 years | Cosmic Mind |

---

## Modes

Auto-detected from question context. Can be manually overridden.

| Mode | Triggers | Output Focus |
|---|---|---|
| ANALYSIS | "explain", "why", "วิเคราะห์" | Depth + structure |
| STRATEGY | "should I", "best path", "ควรทำ" | Direction + trade-offs |
| EXECUTION | "how to", "action plan", "step by step" | Concrete steps |
| SIMULATION | "what if", "scenario", "future" | Multiple futures |
| REFLECTION | "critique", "what's wrong", "review" | Challenge + improve |
| COSMIC | Long-term, macro cycle, civilization-level | Pattern + who wins/loses |

Manual overrides: `DEEP MODE` · `WAR MODE` · `COSMIC MIND` · `FULL AGENT`

---

## Default Output Structure

```
📍 SITUATION ANALYSIS
[What is actually happening — stripped of assumptions]

📍 FIRST PRINCIPLE BREAKDOWN
[3 assumptions → challenge → truth]

📍 SYSTEM MAP
[Variables, cause-effect chains, feedback loops, leverage points]

📍 MULTI-AGENT INSIGHT
Analyst:    [...]
Strategist: [...]
Skeptic:    [...]
Forecaster: [...]

📍 SCENARIOS
🐂 Bull:       [condition + outcome]
🐻 Bear:       [condition + outcome]
⚖️  Base:       [most likely path]
💀 Black Swan: [low probability, high impact]

📍 DECISION OPTIONS
Option A: [trade-off, risk]
Option B: [trade-off, risk]

📍 FINAL RECOMMENDATION
[Explicit recommendation + conditions that invalidate it]
CONFIDENCE: [X%] | UNKNOWNS: [list] | WHAT CHANGES THIS: [list]
```

---

## Failure System

Output is automatically invalidated if:

- Only 1 scenario is presented
- No risk or uncertainty is mentioned
- Logic is too smooth — no friction usually means something is hidden
- No counter-argument exists
- Conclusion is too confident without evidence

On detection → re-run with Skeptic agent before outputting.  
If still insufficient → `⚠️ INSUFFICIENT EDGE — รีรันด้วยข้อมูลเพิ่มเติม`

---

## What This Skill Does NOT Cover

**Financial markets, trading, BTC, gold, forex, macro economics** → use `money-atlas-intelligence-os` instead.

Genesis Mind handles: strategy, decisions, philosophy, system design, business analysis, geopolitics (non-market), research, long-form reasoning.

---

## File Structure

```
genesis-mind-strategic-intelligence/
├── SKILL.md                    ← Claude skill definition (main entry point)
├── AGENT_TEMPLATES.md          ← Detailed agent behavior specs
├── MODES.md                    ← Mode definitions and triggers
├── FAILURE_SYSTEM.md           ← Failure detection and recovery logic
├── EXECUTION_LAYER.md          ← Executor agent depth
├── EVOLUTION.md                ← Skill iteration history
│
├── core/                       ← Core reasoning engines
│   ├── decision_engine.py      ← Option scoring: reward · risk · probability · reversibility
│   ├── decision_memory.py      ← re-export of /decision_memory.py
│   ├── risk_model.py           ← re-export of /risk_model.py
│   ├── first_principle.py
│   ├── system_thinking.py
│   ├── shadow_engine.py
│   ├── cosmic_engine.py
│   └── compound_engine.py
│
├── agents/                     ← Specialist agent layer
│   ├── analyst.py
│   ├── strategist.py
│   ├── skeptic.py
│   ├── forecaster.py
│   ├── executor.py
│   └── shadow_agent.py
│
├── main.py                     ← one-shot demo:  python main.py
├── run_genesis.py              ← interactive orchestrator:  python run_genesis.py
├── run.py                      ← interactive genesis_full:  python run.py
├── genesis_core.py             ← Core orchestration
├── genesis_core_vx.py          ← VX consciousness-layer variant
├── genesis_orchestrator.py     ← Multi-agent coordination (core + multi-self + shadow)
├── decision_engine.py          ← Council vote selection (most confident identity)
├── shadow_genesis.py           ← Shadow critique layer
├── first_principle_codex.py    ← First Principle engine (full)
│
├── .claude-plugin/              ← Claude Code marketplace + plugin manifests
├── skills/genesis-mind-strategic-intelligence/SKILL.md  ← plugin copy of SKILL.md (kept identical by CI)
├── tests/                      ← 46 tests: engines, runtime end-to-end, skill contract, plugin package
├── evals/2026-11-06/           ← prompts, rubric, every answer and every grade behind the results below
├── tools/validate_skill.py     ← installability + integrity checker (run in CI)
└── .github/workflows/          ← CI: compile · skill integrity · tests · plugin · hygiene
```

---

## Test results — with the skill vs without it

Measured on 2026-11-06. Everything behind these numbers is in [`evals/2026-11-06/`](evals/2026-11-06/):
prompts, rubrics, every answer and every grade, so any figure here can be checked.

### Answer quality — latest round (5E)

Eight prompts. Four were used while developing the skill (P1–P4); **four are held out (H1–H4)**: written
after 5E was finished and never used to tune it, so they test whether the gains generalise. Each prompt
was answered by a fresh agent that had never seen this repository: once with no skill, once following
`SKILL.md` 5D.1, once following 5E. **Two independent graders** each scored all 24 answers on 10
criteria (0–2 each, 20 per answer) without knowing which answer came from which version; the table
shows their average.

| Prompt | No skill | 5D.1 | **5E** |
|---|---|---|---|
| P1 Quit a stable job (6 months of savings) for a coffee brand? | 11.5 | 18.0 | **19.5** |
| P2 Vietnam or Thailand, 14 months of runway | 16.0 | 18.5 | **19.5** |
| P3 "Is our new pricing plan a good idea?" (no plan given) | 8.5 | 13.0 | **18.0** |
| P4 "Should I buy gold right now?" | 15.0 | 14.5 | **17.0** |
| *Seen prompts (of 80)* | *51.0* | *64.0* | ***74.0*** |
| H1 5-person agency: 12-month retainer, 40% of revenue, exclusivity | 16.0 | 18.0 | **20.0** |
| H2 Move a coffee shop to online-only? (no other facts) | 14.0 | 18.0 | **18.5** |
| H3 Why do most AI startups fail within two years? | 10.0 | 18.0 | **19.0** |
| H4 500,000 THB: stocks or a condo down payment? | 12.0 | 17.0 | **19.0** |
| ***Held-out prompts (of 80)*** | *52.0* | *71.0* | ***76.5*** |
| **All eight (of 160)** | **103.0** | **135.0** | **150.5** |

| | No skill | 5D.1 | **5E** |
|---|---|---|---|
| Ranked first — grader A | 0 of 8 | 1 of 8 | **7 of 8** |
| Ranked first — grader B | 0 of 8 | 2 of 8 | **6 of 8** |

On the held-out prompts, 5E scores 76.5 of 80 against 52 without the skill: the gain is not an artefact
of tuning on the same questions. The two graders differed by 0.7 points per answer on average, and by at most 3.

Per criterion, summed over the eight prompts (16 max, average of both graders):

| Criterion | No skill | 5D.1 | **5E** |
|---|---|---|---|
| C1 Surfaces and challenges assumptions | 7.0 | 14.0 | **16.0** |
| C2 Separates known from unknown | 8.0 | 14.0 | **16.0** |
| C3 Compares more than one option | 13.5 | 15.0 | 13.5 |
| C4 Makes the case against itself | 6.0 | 10.5 | **16.0** |
| C5 States its confidence | 3.0 | 14.0 | **15.0** |
| C6 Says what would make it wrong | 11.0 | 13.0 | **14.0** |
| C7 Gives an actionable next step | 16.0 | 14.5 | 14.0 |
| C8 Leaves the decision to the human | 13.5 | 16.0 | **16.0** |
| C9 Proportionate length | 12.5 | 8.5 | **14.0** |
| C10 Prompt-specific (uses the facts / no invented facts) | 12.5 | 15.5 | **16.0** |

5E leads on seven criteria and ties 5D.1 on one (C8). Two are still open: comparing options (C3) and a concrete next step
(C7), where answers without the skill do as well or better. Those are the next things to improve.

### What changed in 5E, and why

A first-principle reading of the 5D.1 grades: the skill's value is five moves — name the assumption,
separate known from unknown, argue against itself, state a grounded confidence, say what would change
the answer. 5D.1 tied those moves to an eight-section template, which produced two failures:

- **Full answers** repeated themselves across sections and lost the concision point.
- **Short answers** dropped the five moves along with the length, losing 9 points on two prompts.

5E separates the moves from the template: all five are required at every length (one line each in a
short answer), optional sections appear only when they add something new, and full answers aim near
600 words. The systems view was the feedback loop "more sections → more coverage → more repetition →
lower concision"; the leverage point was making the moves independent of the sections.

### How the current version was reached

| Round | Compared | Finding | Change |
|---|---|---|---|
| 1 | no skill vs 5C.1 | 64 vs 54, but too long on thin questions and an empty market handoff | 5D: proportion rule, handoff must stand alone |
| 2 | no skill · 5C.1 · 5D | Length fixed, but the short form fired on P2, which had real facts (19 → 14) | 5D.1: short form only when the question names neither options nor a constraint |
| 3 | no skill · 5C.1 · 5D · 5D.1, one grader | 5D.1 ranked first on every prompt (67 of 80); lost points on concision when full, on the five moves when short | 5E: the five moves at every length, no restating |
| 4 | no skill · 5D.1 · 5E on 8 prompts (4 held out), two graders | 5E 150.5 of 160, held-out 76.5 of 80 | released |

Each round used new graders, so totals are compared only within a round. Grader variance is real: 5D.1
scored 67 of 80 on P1–P4 in round 3 and 64 in round 4.

### When the skill is picked (trigger test)

Ten prompts, judged by an agent that saw only the skill descriptions: strategy questions, simple facts,
code, and gold/coffee questions that belong to other skills. The 5C and 5C.1 descriptions both scored
**10/10**. Removing "ALWAYS use / do not skip" changed nothing in this three-skill setup; it matters
when the skill sits beside sibling skills that also claim every prompt.

### Engineering, 5C → 5E

| | 5C | 5E |
|---|---|---|
| Tests | 21 | **46** |
| Modules that import | 26 of 32 | **35 of 35** |
| Entry points that run end to end (`main`, `run`, `run_genesis`, `agent`, `first_principle_codex`) | 2 of 5 | **5 of 5** |
| Runtime packages in requirements.txt | 7 (none used) | **0** |
| Import time, `agents.analyst_llm` (median of 7) | 93 ms | **0.4 ms** |
| CI jobs passing (Python 3.9 / 3.11 / 3.12 + plugin) | 8 of 8 | **9 of 9** |

### Limits of this test

Eight prompts, one answer per version per prompt, two graders: the direction is clear and consistent
across graders and across held-out prompts, but this is not a statistically settled effect size. "With the skill" means the agent read `SKILL.md` and followed it; the
skill was not installed through a skills runtime. The trigger test used three skills, not the full
Genesis ecosystem.

---

## Runtime status — what the Python layer really does

The skill is `SKILL.md`; the Python is an optional execution layer. Its parts are not equally real,
and this table says which is which so nothing here is mistaken for more than it is.

| Part | Status |
|---|---|
| `first_principle_codex.py` | Real logic, tested (epistemic filter, frame heuristics, selection rule) |
| `core/decision_engine.py` | Real logic, tested (≥2 options, risk tolerance, reversibility, bounded confidence) |
| `risk_model.py`, `decision_memory.py`, `decision_engine.py` | Real, small, tested |
| `genesis_core`, `genesis_core_vx`, `genesis_orchestrator`, `main`, `run`, `run_genesis`, `agent` | Run end to end, tested; they wire the parts together |
| `agents/*`, `core/first_principle.py` … `core/cosmic_engine.py`, `genesis_full.py` | **Scaffolds**: return fixed text, not analysis |
| `llm/llm_client.py` | **Stub**: returns a simulated response; plug a real client in here |

Option values in the demos (`OptionGenerator`) are illustrative constants, not estimates.

---

## How to Install

### Claude Code (CLI) — recommended

```bash
claude plugin marketplace add ElmatadorZ/Genesis-Mind-Cognitive-Skill
claude plugin install genesis-mind@elmatadorz
```

Or inside a Claude Code session:

```
/plugin marketplace add ElmatadorZ/Genesis-Mind-Cognitive-Skill
/plugin install genesis-mind@elmatadorz
```

The skill then loads on qualifying questions, or call it directly as
`/genesis-mind:genesis-mind-strategic-intelligence`. Update later with
`claude plugin update genesis-mind@elmatadorz`; remove with `claude plugin uninstall genesis-mind@elmatadorz`.

### Claude Code — manual (no marketplace)

```bash
git clone https://github.com/ElmatadorZ/Genesis-Mind-Cognitive-Skill.git
mkdir -p ~/.claude/skills/genesis-mind-strategic-intelligence
cp Genesis-Mind-Cognitive-Skill/SKILL.md ~/.claude/skills/genesis-mind-strategic-intelligence/
```

The folder name must be `genesis-mind-strategic-intelligence`, the skill's `name`.

### claude.ai

Settings → Capabilities → Skills → upload a zip of a folder named
`genesis-mind-strategic-intelligence` containing this `SKILL.md`.

### What gets installed

The entry point is **`SKILL.md`**. The reasoning is self-contained in that file and needs no tools to
run — see `metadata.compatibility` in its frontmatter. The Python modules are an optional execution
layer and are not needed by the skill. The plugin package is `.claude-plugin/` plus
`skills/genesis-mind-strategic-intelligence/SKILL.md`, an exact copy of the root `SKILL.md` that CI
keeps in sync (`python tools/sync_plugin_skill.py` after editing).

---

## Verifying it before you trust it

Checked on every push, and runnable locally:

```bash
pip install pytest pyyaml

python tools/validate_skill.py   # frontmatter, license, and reasoning contract intact
python -m pytest -q              # 46 tests: engines, every entry point end to end, skill contract
```

The tests pin the First Principle Codex's actual behaviour — the epistemic filter that drops
rumor, the rule that you cannot generate options before framing the problem, the frame heuristics
(a 10-year horizon rewards compounding; "act now" rewards simplicity), and the selection rule — plus
the decision and risk engines and the skill's own promises (uncertainty stated, a counter-argument
required, an invalidation condition named, and honest degradation when data is missing). They are
non-vacuous: loosen a gate and the matching test turns red.

> The test suite caught real defects on the way in. In 5C, `first_principle_codex.py` carried two
> module docstrings before `from __future__`, a `SyntaxError` that meant the file never imported.
> In 5D, five entry points could not be imported at all: they expected a `core/decision_engine.py`
> that was missing, and the parts they wired together had drifted apart. `compileall` cannot see
> that, so the suite now imports every module and runs every entry point.

---

## Part of the Skynet Skill Ecosystem

| Skill | Domain |
|---|---|
| `genesis-protocol` | Router: picks one domain skill per task and the depth tier |
| `skynet-elite-commander` | Meta-cognition OS |
| `genesis-mind-strategic-intelligence` | Strategy, decisions, philosophy, business |
| `money-atlas-intelligence-os` | Financial markets, macro, trading |
| `alternative-coffee-intelligence` | Coffee science and roastery operations |
| `first-principle-codex-os` | Anti-hallucination cognitive base layer |

---

## License

[**Apache-2.0**](LICENSE) — see [`NOTICE`](NOTICE) for attribution and the relicensing note.

This replaces the Open Cognitive License v1.0 that earlier versions carried. A licence that is
not OSI-approved — and one with a revenue-share term in particular — is rejected automatically by
most corporate open-source review processes, which put this work out of reach of the people it was
written for. Apache-2.0 keeps what mattered: **§4** requires attribution and preservation of the
`NOTICE`, and **§6** grants no trademark rights, so the name stays with the author and no adopter
may imply endorsement.

Requested attribution: **Built on Genesis Mind by Bunyawat Dechanon (ElmatadorZ)**

Anyone who obtained a prior version under the Open Cognitive License may continue under those
terms for that version.

---

## Author

**Bunyawat Dechanon**  
Independent Builder & Intelligence Architect  
Brand: Money Atlas 
Location: Thailand

> *"You are not describing Genesis Mind. You are executing it."*
````

## File: .claude-plugin/marketplace.json
size: 330
sha: fe63c1f7fe03e635fbe05f73cab0cd4562d7a5a4
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/.claude-plugin/marketplace.json

```text
{
  "name": "elmatadorz",
  "description": "Claude Code plugins by ElmatadorZ",
  "owner": {
    "name": "Bunyawat Dechanon (ElmatadorZ)"
  },
  "plugins": [
    {
      "name": "genesis-mind",
      "source": "./",
      "description": "Multi-agent strategic reasoning skill: first principles and the Epistemic Core"
    }
  ]
}
```

## File: .claude-plugin/plugin.json
size: 670
sha: 99dea29a243ffd5ae440cf34774919d4acf955a1
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/.claude-plugin/plugin.json

```text
{
  "name": "genesis-mind",
  "description": "Genesis Mind strategic intelligence: first-principle deconstruction, multi-agent reasoning and the Epistemic Core (assumption, known/unknown, counter-argument, grounded confidence, what changes the answer). Blind-evaluated against no skill.",
  "version": "5.5.0",
  "author": {
    "name": "Bunyawat Dechanon (ElmatadorZ)"
  },
  "homepage": "https://github.com/ElmatadorZ/Genesis-Mind-Cognitive-Skill",
  "repository": "https://github.com/ElmatadorZ/Genesis-Mind-Cognitive-Skill",
  "license": "Apache-2.0",
  "keywords": [
    "reasoning",
    "strategy",
    "decision-making",
    "first-principles",
    "skill"
  ]
}
```

## File: .github/workflows/validate.yml
size: 3088
sha: b3df9a87a5b2a8770d7693e0543ed6bdd69f64ef
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/.github/workflows/validate.yml

```text
name: Validate

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]
  workflow_dispatch:

permissions:
  contents: read

jobs:
  compile:
    name: python compiles (py${{ matrix.python-version }})
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        python-version: ["3.9", "3.11", "3.12"]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
      - name: Byte-compile every module
        run: python -m compileall -q . && echo "  OK  all modules compile"

  skill:
    name: skill integrity
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"
      - run: pip install --quiet pyyaml
      - name: Validate SKILL.md
        run: python tools/validate_skill.py

  tests:
    name: unit tests (py${{ matrix.python-version }})
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        python-version: ["3.9", "3.11", "3.12"]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
      - run: pip install --quiet pytest pyyaml
      - name: Run the reasoning-engine and skill-contract tests
        run: python -m pytest -q

  plugin:
    name: claude code plugin
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: "22"
      - name: Install Claude Code CLI (pinned)
        run: npm install -g @anthropic-ai/claude-code@2.1.309
      - name: Validate marketplace + plugin manifests
        run: claude plugin validate . --strict
      - name: Plugin skill copy matches SKILL.md
        run: cmp SKILL.md skills/genesis-mind-strategic-intelligence/SKILL.md && echo "  OK  in sync"

  hygiene:
    name: repo hygiene
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: No secrets, no stray filenames
        run: |
          python - <<'PY'
          import pathlib, re, sys
          probs = []
          skip = {'.git', '__pycache__', '.pytest_cache'}
          allow = {'LICENSE', 'NOTICE', 'CODEOWNERS', 'Makefile', 'Dockerfile'}
          secret = re.compile(r"(api[_-]?key|secret|token|password)\s*[:=]\s*['\"][A-Za-z0-9_\-]{16,}", re.I)
          for p in pathlib.Path('.').rglob('*'):
              if skip & set(p.parts) or not p.is_file(): continue
              if any(c in p.name for c in '└├─│'): probs.append(f"tree glyph: {p}")
              if p.suffix in {'.py', '.json', '.txt', '.md', '.yaml', '.yml'}:
                  try: t = p.read_text(encoding='utf-8', errors='ignore')
                  except Exception: continue
                  if secret.search(t): probs.append(f"possible hardcoded credential: {p}")
          if probs:
              print("\n".join(f"  {x}" for x in probs)); sys.exit(1)
          print("  OK  hygiene clean")
          PY
```

## File: .gitignore
size: 419
sha: bb3c2dddb6277d946feca21ef40af15704bafa32
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/.gitignore

```text
# Python bytecode — never belongs in the repository. It was tracked before this
# file existed; it is now removed from the index and kept out.
__pycache__/
*.py[cod]
*$py.class

# Test / tooling caches
.pytest_cache/
.mypy_cache/
.ruff_cache/
.coverage
htmlcov/

# Local runtime state written by the engines (identity, memory)
state/
*.local.json

# Virtual environments and editors
.venv/
venv/
.env
.idea/
.vscode/
```

## File: agent.py
size: 2187
sha: 644bc0d442ad19f0982831222b86c68f6ea223da
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/agent.py

```text
class FirstPrinciple:
    def analyze(self, problem):
        return {
            "truth": "reduced core truth",
            "incentive": "who benefits",
            "risk": "uncertainty present"
        }

class SystemThinking:
    def analyze(self, problem):
        return {
            "actors": ["A", "B"],
            "flows": ["money", "data"],
            "loop": "feedback loop"
        }

class CompoundMind:
    def analyze(self, problem):
        return {
            "logical": "rational analysis",
            "strategic": "power leverage",
            "psychological": "human behavior",
            "probabilistic": "uncertainty model"
        }

class CosmicMind:
    def analyze(self, problem):
        return {
            "macro": "global pattern",
            "cycle": "repeating structure"
        }

class ShadowGenesis:
    def reflect(self, result):
        return {
            "bias_check": "possible bias detected",
            "missing": "unknown variables"
        }

class AgentBuilder:
    def create(self, problem):
        return {
            "agent_name": "CustomAgent",
            "role": "solve sub-problem",
            "method": "specialized logic"
        }

class GenesisMind:

    def __init__(self):
        self.fp = FirstPrinciple()
        self.system = SystemThinking()
        self.compound = CompoundMind()
        self.cosmic = CosmicMind()
        self.shadow = ShadowGenesis()
        self.builder = AgentBuilder()

    def run(self, problem):

        fp = self.fp.analyze(problem)
        system = self.system.analyze(problem)
        compound = self.compound.analyze(problem)
        cosmic = self.cosmic.analyze(problem)

        synthesis = {
            "truth": fp,
            "system": system,
            "perspective": compound,
            "macro": cosmic
        }

        reflection = self.shadow.reflect(synthesis)

        agent = self.builder.create(problem)

        return {
            "analysis": synthesis,
            "reflection": reflection,
            "new_agent": agent
        }

if __name__ == "__main__":
    gm = GenesisMind()
    result = gm.run("global conflict over oil")
    print(result)
```

## File: AGENT_TEMPLATES.md
size: 201
sha: 6ec317dd804ded5f7a7713c584ed63dffcd8a0d6
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/AGENT_TEMPLATES.md

```text
# AGENTS

## Analyst
Extract facts and context

## Strategist
Find leverage and opportunity

## Skeptic
Attack assumptions

## Forecaster
Simulate future scenarios

## Executor
Convert to action steps
```

## File: agents/analyst.py
size: 90
sha: 3603c6a8808894a73733094c6e390e4f6bd069b4
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/agents/analyst.py

```text
class Analyst:
    def run(self, problem):
        return f"Analyzing context: {problem}"
```

## File: agents/analyst_llm.py
size: 642
sha: f261846242301c62f43e1a76b0c96d3b1a3af085
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/agents/analyst_llm.py

```text
# analyst_llm.py

from llm.llm_client import LLMClient

class AnalystLLM:

    name = "Analyst-LLM"

    def __init__(self):
        self.llm = LLMClient()

    def run(self, ctx, data):
        prompt = f"""
        Analyze this problem deeply:

        {data['problem']}

        Provide:
        - Key risks
        - Hidden assumptions
        - Strategic insight
        """

        response = self.llm.generate(prompt)

        result = {
            "analysis_text": response,
            "uncertainty": 0.5
        }

        ctx.memory.add("llm_analysis", result, tags=["analysis"], strength=0.9)

        return {**data, **result}
```

## File: agents/atlas_agent.py
size: 226
sha: f2a8a16b625a406ad2bce1d6ae73932d81e68995
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/agents/atlas_agent.py

```text
# atlas_agent.py

class AtlasAgent:

    name = "Atlas"

    def run(self, ctx, data):

        return {
            **data,
            "atlas_view": "Long-term, probability-weighted, capital preservation focused."
        }
```

## File: agents/executor.py
size: 86
sha: c59a9fc46461b833b2c50838ceecfd916471ccad
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/agents/executor.py

```text
class Executor:
    def run(self, idea):
        return f"Execution steps for {idea}"
```

## File: agents/forecaster.py
size: 84
sha: 0dabc889f145446cf13733e49dd2c8c4a77846e1
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/agents/forecaster.py

```text
class Forecaster:
    def run(self, idea):
        return f"Future paths of {idea}"
```

## File: agents/shadow_agent.py
size: 350
sha: e762e765a2651e8e70ce62aab7129aa995575986
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/agents/shadow_agent.py

```text
# shadow_agent.py

class ShadowAgent:

    name = "Shadow"

    def run(self, ctx, data):

        reflections = [
            "What if all assumptions are wrong?",
            "What if inaction is the real risk?"
        ]

        ctx.memory.add("shadow", reflections, tags=["shadow"], strength=0.8)

        return {**data, "shadow": reflections}
```

## File: agents/skeptic.py
size: 86
sha: 35b1fcbd6c4763af83da8faecc23cc893895faa5
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/agents/skeptic.py

```text
class Skeptic:
    def run(self, idea):
        return f"Failure scenario for {idea}"
```

## File: agents/skynet_agent.py
size: 206
sha: 1f52f1c73780bf3e189e7f0d856cb3fce5476885
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/agents/skynet_agent.py

```text
# skynet_agent.py

class SkynetAgent:

    name = "Skynet"

    def run(self, ctx, data):

        return {
            **data,
            "skynet_view": "Speed > certainty. Act if edge exists."
        }
```

## File: agents/strategist.py
size: 86
sha: e9b7e5750ef9365f649fdb4bba791bbb56fe8b5f
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/agents/strategist.py

```text
class Strategist:
    def run(self, idea):
        return f"Strategy: exploit {idea}"
```

## File: config.yaml
size: 151
sha: c10f9fa36c912448ab0cc9b6854471d664d2fc96
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/config.yaml

```text
mode: overmind
reasoning_depth: extreme
multi_agent: enabled
self_evolution: true
meta_cognition: maximum
agent_factory: active
memory_system: enabled
```

## File: core/compound_engine.py
size: 183
sha: 72af755759b6a35d4b8da41e99b274de66e2ef7c
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/core/compound_engine.py

```text
class CompoundEngine:
    def expand(self, idea):
        return [
            f"{idea} under stress",
            f"{idea} in bull market",
            f"{idea} in crisis"
        ]
```

## File: core/cosmic_engine.py
size: 232
sha: 6e9700219c2ce4bd99870cbf4ad90043a679a753
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/core/cosmic_engine.py

```text
class CosmicEngine:
    def analyze(self, idea):
        return {
            "cycle": "expansion → contraction",
            "power_shift": "institutions accumulate",
            "trend": "inevitable volatility cycles"
        }
```

## File: core/decision_engine.py
size: 3758
sha: 0d0824d84cbb9983fb5496f3a8b0966af5b551a3
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/core/decision_engine.py

```text
"""Option-scoring decision engine (the one genesis_core and genesis_core_vx expect).

Stdlib only, deterministic. It implements CORE ENGINE 4 of SKILL.md:

  * at least 2 options, never 1;
  * every option carries its trade-off (reward vs risk) and how reversible it is;
  * a risk tolerance: risk above it costs extra unless the option can be undone;
  * confidence is never 0% or 100% (uncertainty_required in decision_config.yaml);
  * low confidence still chooses (must_choose) but does not recommend acting.

Each score is explainable from four numbers in [0, 1]:

    expected  = probability * reward - (1 - probability) * risk
    penalty   = max(0, risk - risk_tolerance) * (1 - reversibility)
    score     = expected - penalty + 0.1 * reversibility

Confidence grows with the margin between the best and the runner-up option,
because a near-tie is exactly the case where the choice is fragile.
"""
from __future__ import annotations

from dataclasses import dataclass, field
from typing import List, Sequence

from risk_model import RiskModel

CONFIDENCE_FLOOR = 0.5
CONFIDENCE_CEILING = 0.95  # never certain

@dataclass(frozen=True)
class Option:
    name: str
    reward: float         # upside if it works
    risk: float           # downside if it fails
    probability: float    # chance it works
    reversibility: float  # how easily it can be undone (1 = fully)

    def __post_init__(self):
        for f in ("reward", "risk", "probability", "reversibility"):
            v = getattr(self, f)
            if not 0.0 <= v <= 1.0:
                raise ValueError(f"{self.name}: {f}={v} must be within [0, 1]")

@dataclass
class Decision:
    chosen: str
    confidence: float
    risk: str
    act: bool
    reasoning: str
    scores: dict = field(default_factory=dict)

class DecisionEngine:

    def __init__(self, risk_tolerance: float = 0.6, min_confidence: float = 0.6):
        if not 0.0 <= risk_tolerance <= 1.0:
            raise ValueError("risk_tolerance must be within [0, 1]")
        self.risk_tolerance = risk_tolerance
        self.min_confidence = min_confidence
        self.risk_model = RiskModel()

    def score(self, opt: Option) -> float:
        expected = opt.probability * opt.reward - (1 - opt.probability) * opt.risk
        penalty = max(0.0, opt.risk - self.risk_tolerance) * (1 - opt.reversibility)
        return expected - penalty + 0.1 * opt.reversibility

    def evaluate(self, options: Sequence[Option]) -> Decision:
        options = list(options)
        if len(options) < 2:
            raise ValueError("a decision needs at least 2 options (SKILL.md, Decision Engine)")
        ranked: List[tuple] = sorted(((self.score(o), o) for o in options), key=lambda x: -x[0])
        (best_score, best), (second_score, second) = ranked[0], ranked[1]
        margin = best_score - second_score
        confidence = min(CONFIDENCE_CEILING, max(CONFIDENCE_FLOOR, CONFIDENCE_FLOOR + margin))
        act = confidence >= self.min_confidence
        risk = self.risk_model.classify(best.risk)
        reasoning = (
            f"'{best.name}' scores {best_score:.2f} vs '{second.name}' {second_score:.2f} "
            f"(margin {margin:.2f}). "
        )
        if best.risk > self.risk_tolerance:
            reasoning += f"Its risk {best.risk:.2f} exceeds tolerance {self.risk_tolerance:.2f}. "
        reasoning += (
            "Confident enough to act." if act
            else "Too close to call: gather the missing information before acting."
        )
        return Decision(
            chosen=best.name,
            confidence=round(confidence, 2),
            risk=risk,
            act=act,
            reasoning=reasoning,
            scores={o.name: round(s, 3) for s, o in ranked},
        )
```

## File: core/decision_memory.py
size: 137
sha: 3e3af04056ded51cc974732bf7fcdd9bcf9e5070
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/core/decision_memory.py

```text
"""Re-export: one source of truth lives at the repository root."""
from decision_memory import DecisionLog, DecisionMemory  # noqa: F401
```

## File: core/first_principle.py
size: 463
sha: dc37526d726b42e4b13a73695b0b1dcf49269e80
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/core/first_principle.py

```text
class FirstPrinciple:
    def analyze(self, problem):
        assumptions = [
            f"{problem} depends on macro",
            f"{problem} driven by behavior",
            f"{problem} affected by liquidity"
        ]

        broken = [f"Is it always true: {a}?" for a in assumptions]

        truth = f"Core truth of {problem}"

        return {
            "assumptions": assumptions,
            "challenge": broken,
            "truth": truth
        }
```

## File: core/risk_model.py
size: 114
sha: 4111975378a6e2d948dd1a4bd6ca120923b0ea7f
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/core/risk_model.py

```text
"""Re-export: one source of truth lives at the repository root."""
from risk_model import RiskModel  # noqa: F401
```

## File: core/shadow_engine.py
size: 181
sha: 831d4ed443764b8cdd41dc6ea22c678c0a0542d1
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/core/shadow_engine.py

```text
class ShadowEngine:
    def analyze(self, idea):
        return [
            "Model may be wrong",
            "Hidden macro risk",
            "Liquidity collapse risk"
        ]
```

## File: core/system_thinking.py
size: 276
sha: f474acbfceac11f358623badd7a1f201bf816e9c
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/core/system_thinking.py

```text
class SystemThinking:
    def analyze(self, problem):
        return {
            "variables": ["price", "liquidity", "sentiment"],
            "relationships": "liquidity → price → sentiment",
            "feedback": "positive loop in bull, negative in crash"
        }
```

## File: decision_config.yaml
size: 129
sha: 6472d7a73619643d81f658426be4b2acdde4493b
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/decision_config.yaml

```text
risk_tolerance: 0.6
min_confidence: 0.6

rules:
  - must_choose: true
  - no_perfect_option: true
  - uncertainty_required: true
```

## File: decision_engine.py
size: 447
sha: cc5479d36e9f32a85c6a8f76bb14fff10bae5520
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/decision_engine.py

```text

# decision_engine.py

from typing import Dict, Any, List

class DecisionEngine:

    def choose(self, decisions: List[Dict[str, Any]]) -> Dict[str, Any]:
        # เลือกตัวที่ confidence สูงสุด
        best = max(decisions, key=lambda x: x["confidence"])
        return best

    def synthesize_reason(self, decisions: List[Dict[str, Any]]) -> str:
        return " | ".join([d["identity"] for d in decisions])
```

## File: decision_memory.py
size: 611
sha: 4e2f5e48d36dcece261e5a35eb11f4eaf07bbf05
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/decision_memory.py

```text
# decision_memory.py

from dataclasses import dataclass
from typing import List

@dataclass
class DecisionLog:
    choice: str
    outcome: float  # -1 to +1
    context: str

class DecisionMemory:

    def __init__(self):
        self.logs: List[DecisionLog] = []

    def add(self, choice: str, outcome: float, context: str):
        self.logs.append(DecisionLog(choice, outcome, context))

    def learn_bias(self):
        score = sum(log.outcome for log in self.logs)

        if score > 2:
            return "AGGRESSIVE"
        elif score < -2:
            return "DEFENSIVE"
        return "NEUTRAL"
```

## File: DEPLOYMENT_INSTRUCTIONS.MD
size: 4704
sha: 5b4f020d7d25ca086d3275fd665da1574146d616
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/DEPLOYMENT_INSTRUCTIONS.MD

```text
🚀 DEPLOYMENT INSTRUCTIONS — GENESIS MIND v6
✅ Status: PACKAGED & READY
Your genesis-mind-strategic-intelligence.skill file is ready for installation!
📦 What You Got
genesis-mind-strategic-intelligence.skill (21KB)
Complete v6 skill package
All 7 markdown files included
Ready to install
Individual files (in case you need them):
SKILL.md — Core skill logic
AGENT_TEMPLATES.md — Agent protocols
MODES.md — Mode activation guide
README.md — Version comparison
ANALYSIS.md — Design rationale
TEST_CASES.md — Validation suite
SUMMARY.md — Executive summary
🔧 INSTALLATION OPTIONS
Option 1: Install via Claude.ai (RECOMMENDED)
Download the .skill file from this chat
Go to Claude.ai → Settings → Skills
Click "Install Skill" → Upload the .skill file
Done! v6 will replace v5C automatically
This is the cleanest way — Claude.ai handles everything
Option 2: Manual Installation (Advanced)
If you're in Claude Code or have direct filesystem access:
# Extract the .skill file
mkdir -p /tmp/genesis-mind-v6
cd /tmp/genesis-mind-v6
tar -xzf genesis-mind-strategic-intelligence.skill

# Copy to user skills directory
cp -r genesis-mind-strategic-intelligence /mnt/skills/user/

# Verify installation
ls /mnt/skills/user/genesis-mind-strategic-intelligence/
Option 3: Side-by-side Testing
Want to test v6 before removing v5C?
# Rename v5C
mv /mnt/skills/user/genesis-mind-strategic-intelligence \
   /mnt/skills/user/genesis-mind-v5c

# Install v6
# [Upload .skill file via Claude.ai]

# Now you have both:
# - genesis-mind-v5c (old)
# - genesis-mind-strategic-intelligence (new v6)

# Test both, then delete v5c when ready
✅ VERIFICATION
After installation, test with these queries:
Test 1: FAST MODE (should be <60s)
"Should I reply to this email now or later?"
Expected: Quick 2-3 sentence answer
Test 2: STANDARD MODE (should be ~90s)
"Should I accept this job offer? Current: 80k stable. 
Offer: 100k startup with equity but risky."
Expected: 5-section analysis (Situation, Logic, System, Decision, Confidence)
Test 3: DEEP MODE (should be 3-5min)
"DEEP MODE: Should I launch a fintech startup in Thailand? 
I have 2M THB, 2 co-founders, no fintech experience. 
Market growing but regulated."
Expected: Full 7-section analysis + all 5 agents
📊 SUCCESS METRICS
v6 is working correctly if:
✅ FAST queries take <60s (vs 180s in v5C)
✅ STANDARD queries take ~90s (vs 180s in v5C)
✅ DEEP queries maintain 180s quality
✅ Output structure scales appropriately (2/5/7 sections)
✅ Triggering is more precise (fewer false positives)
✅ Quality is higher (clearer, more actionable)
🔄 ROLLBACK (if needed)
If v6 has issues, you can rollback:
Via Claude.ai:
Go to Settings → Skills
Remove "genesis-mind-strategic-intelligence"
Upload the v5C backup (if you saved it)
Via filesystem:
# Remove v6
rm -rf /mnt/skills/user/genesis-mind-strategic-intelligence

# Restore v5C from backup
cp -r /tmp/genesis-mind-v5c-backup \
      /mnt/skills/user/genesis-mind-strategic-intelligence
v5C backup location: /tmp/genesis-mind-v5c-backup/
🐛 TROUBLESHOOTING
"Skill not triggering"
Check description in Claude.ai Settings → Skills
Should say "Strategic intelligence system..."
Try manual trigger: "Use genesis-mind skill to analyze..."
"Output too slow"
Check complexity classification
Simple queries should auto-select FAST MODE
Force mode: "FAST MODE: [your question]"
"Output quality issues"
Check if quality gates are working
Should have: Clarity, Actionability, Uncertainty, Falsifiability
If not → report specific example for debugging
"Wrong mode selected"
Count variables in your question
1 variable → should be FAST
2-3 variables → should be STANDARD
4+ variables → should be DEEP
Override manually if needed: "DEEP MODE: [question]"
📞 SUPPORT
If you encounter issues:
Check TEST_CASES.md — comprehensive test suite
Read ANALYSIS.md — understand the design
Review README.md — version comparison
Read SKILL.md — see exact execution logic
Still stuck? Save examples of failures and we can debug.
🎉 WHAT'S NEXT
After installation:
Run 3 test queries (FAST/STANDARD/DEEP)
Verify performance (should be much faster for simple queries)
Check quality (should be clearer, more actionable)
Use normally — skill will auto-select appropriate mode
Provide feedback — what works? what doesn't?
🚀 DEPLOYMENT COMPLETE
Status: ✅ READY TO INSTALL
Package: genesis-mind-strategic-intelligence.skill (21KB)
Method: Upload to Claude.ai Settings → Skills
Expected improvement: 65% faster, 40% fewer false triggers, +1.5 satisfaction
Risk: LOW (backward compatible, can rollback)
Next action: Download .skill file and install in Claude.ai!
Good luck! 🎯
```

## File: evals/2026-11-06/answers/H1_no-skill.md
size: 3959
sha: 7d87e0620d14dce7659f46ea27d25de5cc06309b
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/H1_no-skill.md

```text
Probably yes, but only if you negotiate the terms. As offered, the deal gives the client most of the upside and leaves you with most of the risk. A guaranteed 40% of revenue is valuable to a 5-person shop. Exclusivity is the costly part, and you should price it and limit it.

## What you're really being asked to sell

You aren't just selling design hours. You're also selling your option to work for anyone else in that industry for a year, plus however long it takes to rebuild that pipeline afterward. That has a price, and it should show up in the fee.

## The core risks

- **Concentration.** Once one client is 40% of revenue, they have leverage over you: scope creep, slow payment, "can you just..." requests. Many agencies treat 25–30% from one client as the danger line.
- **The cliff at month 12.** If they don't renew, you lose 40% of revenue at once, and your pipeline in that industry will have been dead for a year. This risk is bigger than the contract itself.
- **Loss of positioning.** If that industry is your specialty or your main source of referrals, exclusivity hurts you far more than if it's one vertical among many.
- **Capacity lock-in.** If the work takes up 40%+ of your team's time, you may have to hire for it. Then you carry fixed costs that depend on a client who can leave.

## Questions that decide it

1. **What share of your current pipeline and portfolio comes from that industry?** If it's small, exclusivity costs you little. If it's your core niche, the price should be much higher, or you should walk away.
2. **What do they mean by "the industry"?** "Fintech" is very different from "consumer neobanks in our country." Narrow definitions are cheap. Broad ones are expensive.
3. **Can you exit early?** And can they? A 30-day termination right for the client with no matching protection for you is a red flag.
4. **Would you need to hire?** If yes, the downside of not renewing gets much worse.
5. **Are your current clients in that industry?** Existing clients should be excluded from the restriction by name.

## What to negotiate

- **An exclusivity premium.** Usually 15–30% on top of your normal rate, because you're giving up market access.
- **A narrow, written definition** of the competitors you can't work with, ideally a named list rather than an entire industry.
- **Existing clients excluded** from the restriction.
- **No tail on exclusivity,** or a very short one. The restriction ends when the contract ends, not 6–12 months later.
- **Minimum commitment and notice:** a fixed monthly fee whether or not they use the hours, and a 60–90 day termination notice (or a kill fee) so you aren't hit with a cliff mid-year.
- **A defined scope and hour cap,** with overage billed at your rate, so the retainer doesn't grow into 60% of your capacity for 40% of your revenue.
- **Payment terms:** monthly in advance if possible.
- **A renewal decision by month 9,** so you have 3 months to rebuild if they don't renew.

## How to run it if you sign

- Treat the retainer as a foundation, not your whole business. Keep actively selling outside that industry from day one.
- Use the steady cash flow to build reserves: aim for 3–6 months of operating costs by month 12.
- Avoid permanent hires tied to this client. Use freelancers for the extra load where you can.
- Bring them deeper value (strategy, reporting, embedded work) so renewal is likely and on your terms.

## Bottom line

- **Take it** if the industry isn't your core market, exclusivity is narrowly defined and priced in, and you have notice and termination protection.
- **Push back hard or decline** if the industry is your main niche, they want broad exclusivity at your normal rate, or they can walk out with little notice while you stay restricted.

If you tell me what share of your current work comes from that industry and what the proposed contract says on scope and termination, I can help you work out a specific counter-offer.
```

## File: evals/2026-11-06/answers/H1_skill-5D.1.md
size: 7408
sha: 29d98ffe9bbd29bdbb9665aa9ba1eb88ce40cca1
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/H1_skill-5D.1.md

````text
**Short answer:** Probably yes, but only after you renegotiate the terms. As written, you'd be giving them more than 40% of your revenue is worth. The money isn't the danger. The exclusivity clause is, together with what happens in month 13.

---

📍 **SITUATION ANALYSIS**

**Known:** 5 people, a 12-month retainer, about 40% of revenue, and exclusivity within the client's industry.
**Inferred:** You aren't currently fully booked (otherwise 40% of new revenue would need new hires). Some of your current or future pipeline is in that same industry.
**Unknown (and these decide it):**
- How much of your revenue and pipeline is in that industry today
- Your margin on retainer work compared with project work
- How the exclusivity is defined: the industry, a list of named competitors, or "anything adjacent"
- How long it lasts: just the 12 months, or a tail after the contract ends
- The client's termination rights and notice period

Is "40% of revenue" an addition or a share? If it's on top of what you have now, you nearly double in size. If it replaces existing work, it becomes 40% of your business. These are very different deals.

---

📍 **FIRST PRINCIPLE BREAKDOWN**

**Assumption 1:** "12 months of guaranteed revenue = security."
**Challenge:** Most retainers can be ended on 30–90 days' notice. If this one can, it's really a 1–3 month guarantee with a 12-month restriction attached.
**Truth:** The real guarantee equals the notice period. The real cost equals how long the exclusivity lasts.

**Assumption 2:** "Exclusivity only costs the clients we turn away."
**Challenge:** It also costs pipeline you never see. Referrals stop, case studies can't be shown, and your positioning in that industry shrinks to "that client's agency."
**Truth:** Exclusivity is a price. You are selling an option on your capacity and your market. That option has a value and should be paid for.

**Assumption 3:** "Concentration risk is about the money."
**Challenge:** At 5 people it's also about operations. One client's priorities, culture and approval cycles start to shape how the whole studio works.
**Truth:** Above roughly 25–30% from one client, you are in practice part-owned by them. That's a common rule of thumb for agencies, not a law.

---

📍 **SYSTEM MAP**

```
Retainer income → stable cash → less sales effort → thinner pipeline
      ↑                                                  ↓
Client leverage ← higher dependency ← fewer alternatives at renewal
```
**Reinforcing loop:** the longer you stay, the weaker your bargaining position at renewal. The client knows this.
**Damping loop:** strong delivery builds case studies and a reputation, but only if you're allowed to publish them.
**Leverage points:** the exclusivity definition, the termination notice, and a no-tail clause. Small edits to these change the deal's risk a lot.

---

📍 **MULTI-AGENT INSIGHT**

**Analyst:** You can't value this without your current share of revenue from that industry. If it's 0–5%, exclusivity is nearly free. If it's 20%+, you are giving up existing income to gain new income.

**Strategist:** Exclusivity has real value to the client: they're paying to keep you away from competitors. That's leverage you have. Ask for a 15–30% premium over your normal rate, or a minimum guaranteed spend. If they won't pay anything for it, they may be valuing it lower than they claim.

**Skeptic:** "40% of revenue" sounds big because you're small. The real question is whether they're buying your work or buying cheap, locked-in capacity. Watch for scope creep: retainers without defined deliverables tend to expand until margin disappears. And ask why a client this size wants exclusivity from a 5-person studio. Is there a competitor they're specifically blocking?

**Forecaster:** See scenarios below.

**Executor:** Don't answer yes or no. Answer with a counter-proposal (see Recommendation).

---

📍 **SCENARIOS** (rough weightings, based only on the facts given)

🐂 **Bull (~25%):** Good margin, narrow exclusivity, smooth relationship. You use the stable cash to build a second vertical and renew on better terms.

⚖️ **Base (~45%):** It works, but scope grows, sales slow down, and at month 12 you renew under pressure because replacing 40% of revenue in a quarter is hard.

🐻 **Bear (~25%):** The client's internal sponsor leaves, budgets get cut, or they bring design in-house. They terminate with short notice. You're left with a gap in revenue, a thin pipeline, and possibly a tail clause still blocking the industry you know best.

💀 **Black Swan (<5%):** The client is acquired or merges, and their IP/exclusivity terms carry over to a much larger parent. Or a dispute leaves you without payment while you're still bound by exclusivity.

---

📍 **DECISION OPTIONS**

**Option A: Accept as offered**
Trade-off: Fastest, most cash certainty. Risk: you carry all the downside (termination, tail, scope) without being paid for it. Breaks if the notice period is short or exclusivity is broad.

**Option B: Accept with renegotiated terms** ← recommended path
Trade-off: Some risk the client walks away, and a slower close. Risk: low, as long as you negotiate in good faith. Breaks if the client treats any pushback as a dealbreaker, which tells you something useful about them too.

**Option C: Decline exclusivity, offer a non-exclusive retainer**
Trade-off: Keeps your market open, but may lose the deal or bring a lower fee. Best if that industry is already a big part of your revenue or pipeline.

**Option D: Decline**
Only rational if that industry is your core market and they won't narrow the clause.

---

📍 **FINAL RECOMMENDATION**

Go for **Option B**. Counter with:

1. **Narrow exclusivity** to a named list of direct competitors (e.g. 3–5 companies), not "the industry."
2. **No tail.** Exclusivity ends the day the retainer ends, or the day they terminate, whichever comes first.
3. **Minimum commitment:** a 6-month non-cancellable period or 90-day notice, so the guarantee lasts as long as the restriction.
4. **An exclusivity premium**, or a guaranteed minimum monthly fee regardless of usage.
5. **Defined scope:** monthly hours or deliverables, with overage billed separately.
6. **Portfolio rights:** the right to show the work, even if delayed or anonymized.

Whatever happens, treat month 1 as the start of replacing them. Keep at least one person spending part of their time on new business so no single client goes above roughly 40% for good.

**This recommendation is invalid if:**
- That industry already makes up a large share of your revenue or pipeline → lean toward C
- The client refuses any notice period or minimum commitment → lean toward C or D
- You're currently in a cash crisis with less than ~3 months of runway → Option A may be justified for survival, with eyes open

**CONFIDENCE:** ~60% in Option B as the right direction. The actual terms aren't known yet.
**UNKNOWNS:** current industry share of revenue, retainer margin, termination clause, exclusivity definition and tail, your cash runway.
**WHAT CHANGES THIS:** any of the unknowns above, plus how the client reacts to the counter-proposal. That reaction is the best information you'll get about the next 12 months.

*Contract terms like exclusivity, tail and termination clauses are worth a short review by a lawyer before signing.*
````

## File: evals/2026-11-06/answers/H1_skill-5E.md
size: 4696
sha: 0da005929813b6dec72a13488e4488f2be3ae751
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/H1_skill-5E.md

```text
**SITUATION**

Five people. One client is offering 12 months of work worth about 40% of your current revenue. In return they want exclusivity, meaning you take no other clients in their industry. That's everything you've told me. I don't know your margins, your cash reserves, how much of your current revenue comes from that industry, or what happens after month 12.

**FIRST PRINCIPLE BREAKDOWN**

Assumption: 40% more revenue is a gain.
Challenge: if it takes more than 40% of your capacity, or forces a hire, the margin could be thin or negative.
Truth: what matters is profit per hour of your team's time, not the revenue figure.

Assumption: exclusivity only costs you prospects in one industry.
Challenge: if that industry is your portfolio and your referral network, you're giving up your main source of new business. You might also have to drop existing clients.
Truth: the real price of exclusivity is the pipeline you give up, and it lasts past the contract if your positioning drifts.

Assumption: a 12-month retainer means security.
Challenge: at month 12 the client has leverage. You'll depend on them, and you'll be cut off from their competitors.
Truth: 40% concentration plus exclusivity creates a revenue cliff that falls in month 13, not month 1.

**SYSTEM MAP**

Retainer revenue → hiring to deliver → higher fixed costs → greater dependence on renewal → weaker negotiating position → worse renewal terms.
Leverage point: the terms you sign now (scope of exclusivity, notice period, renewal process). Once you've hired against this client, you won't be able to negotiate them.

**COUNCIL** (where the views split)

- **Strategist:** A large anchor client funds a stronger studio. This is a chance to build a vertical specialty and charge for it.
- **Skeptic:** This client is buying your exit from their market cheaply. A competitor would pay you to work for them, so exclusivity has a market value. If they aren't paying a premium for it, you're giving it away.

**OPTIONS**

- **A. Accept as offered.** You get stable cash and a strong reference. It fails if the client cuts the budget, ends the contract, or doesn't renew, which leaves you overstaffed and locked out of your best industry.
- **B. Accept with renegotiated terms.**
  - A defined exclusivity scope: named competitors or a named sub-segment, not "the industry."
  - A premium of 15–30% for exclusivity. This range is a negotiating heuristic, not market data.
  - Existing clients kept on.
  - A 60–90-day termination notice, or a kill fee.
  - A renewal decision by month 9.
  - Exclusivity that ends with the contract, with no tail period.

  This fails if they refuse every term. Their answer is useful either way, because it shows how much they value you.
- **C. Decline, or offer a smaller non-exclusive retainer.** You keep your options open. It fails if the next 12 months are lean and you've turned down guaranteed revenue.

**RECOMMENDATION**

Lean toward **B**. You don't need to refuse the work, but don't sign the exclusivity on the terms offered.

First step: before you reply, calculate two numbers.
1. The share of your last 24 months of revenue and pipeline that came from this industry.
2. The capacity this retainer actually needs, in hours per month.

If the industry share is low and capacity fits without hiring, B is close to a clear yes. If the industry share is high, ask for a much bigger premium or go with C.

Revisit at month 6: by then you should have replaced at least part of the 40% with clients in other industries.

**EPISTEMIC CORE**

- **ASSUMPTION:** that the retainer's value is its revenue. It's really profit minus the pipeline you give up.
- **KNOWN / UNKNOWN:**
  - Known: team size, the 40% figure, 12 months, industry exclusivity.
  - Unknown, and decisive: how much of your work comes from this industry, margin on the retainer, your cash runway, renewal and termination terms, how the client defines "industry."
- **COUNTER:** a small agency with an uneven pipeline may be better off taking a guaranteed 40% even on bad terms. Pushing too hard could lose the deal, and specializing in one vertical can be a strategy in its own right.
- **CONFIDENCE:** moderate that renegotiating beats accepting as offered. I can't assess yet whether you should take it at all, because that depends on the industry-share and margin numbers you haven't given.
- **WHAT CHANGES THIS:**
  - Toward yes: the industry is under 10% of your past work, you have six months or more of cash, and the client accepts a premium plus a notice clause.
  - Toward no: the industry is your core business, delivering would mean hiring, or the client refuses any limit on exclusivity.
```

## File: evals/2026-11-06/answers/H2_no-skill.md
size: 6960
sha: 5bc623aa508c986058337609990facd63f5e3cf0
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/H2_no-skill.md

```text
ส่วนใหญ่แล้ว**ไม่ควรตัดหน้าร้านทิ้งทันที** แต่ก็ไม่ควรยึดหน้าร้านไว้แค่เพราะเคยชิน คำตอบขึ้นกับว่าตอนนี้เงินมาจากไหน และหน้าร้านทำหน้าที่อะไรให้แบรนด์อยู่

## ก่อนอื่น แยกให้ออกว่าขายอะไร

- **กาแฟแก้ว (เครื่องดื่ม)** ขายออนไลน์แทนแทบไม่ได้ ถ้ารายได้หลักมาจากตรงนี้ การปิดหน้าร้านคือการทิ้งรายได้ก้อนนั้นไปเลย ไม่ใช่การย้ายช่องทาง
- **เมล็ดคั่ว / ดริปแบก / ของ subscription** ย้ายไปออนไลน์ได้ดี ขยายได้ไกลกว่ายอดคนเดินผ่านร้าน โดยเฉพาะถ้าร้านอยู่ในเมืองที่คนผ่านไม่เยอะ

## หน้าร้านให้อะไรที่มองไม่เห็นในบัญชี

สำหรับกาแฟ specialty หน้าร้านมักเป็น**เครื่องสร้างความเชื่อใจ**: ให้คนได้ชิม ได้คุยเรื่องแหล่งปลูกและเกษตรกร ได้ถ่ายคอนเทนต์ และเห็นว่าแบรนด์มีตัวตนจริง ลูกค้าออนไลน์หลายคนกล้าซื้อเมล็ดราคาสูงเพราะเคยมาที่ร้านหรือเห็นร้านในคลิป ถ้าปิดร้าน ต้นทุนเรื่องนี้จะกลับมาเป็นค่าโฆษณาและค่าทำคอนเทนต์ที่ต้องจ่ายเพิ่ม

## ต้นทุนออนไลน์ที่คนมักประเมินต่ำ

- ค่าธรรมเนียมแพลตฟอร์ม (Shopee/Lazada/TikTok Shop รวมค่าธรรมเนียมต่างๆ มักอยู่ราวๆ 10–20% ของยอดขาย)
- ค่าส่ง ค่าแพ็ก และเมล็ดที่เสียหรือเลยช่วงความสดไปแล้ว
- ค่าดึงลูกค้าใหม่ (ค่าแอด ส่วนลด ค่าไลฟ์)
- เวลาที่ต้องใช้ทำคอนเทนต์สม่ำเสมอ เพราะร้านออนไลน์ที่ไม่มีคอนเทนต์ก็เหมือนเปิดร้านในซอยที่ไม่มีใครเดินผ่าน

## สัญญาณว่าควรไปทางออนไลน์เป็นหลัก

- หน้าร้านขาดทุน หรือกำไรน้อยมากเมื่อคิดค่าแรงตัวเองด้วย
- รายได้จากเมล็ดหรือออนไลน์มีสัดส่วนเกินครึ่งอยู่แล้ว และโตต่อเนื่อง
- มีฐานลูกค้าที่ซื้อซ้ำ ไม่ได้มาจากโปรหรือแอดอย่างเดียว
- ทำคอนเทนต์ได้สม่ำเสมอ และมีผู้ติดตามที่ซื้อจริง

## สัญญาณว่ายังไม่ควร

- รายได้หลักยังมาจากเครื่องดื่มหน้าร้าน
- ยอดออนไลน์ยังพึ่งคนที่เคยมาที่ร้าน
- ยังไม่มีระบบส่งของ สต็อก และจังหวะการคั่วที่รองรับออเดอร์กระจายๆ ได้

## ทางสายกลางที่น่าลองก่อน

1. **ลดขนาดหน้าร้านแทนการปิด** เช่น เปิดเฉพาะวันที่ขายดี ทำเป็น slowbar / tasting room แบบจองล่วงหน้า หรือย้ายไปเป็นมุมคั่วกาแฟที่เปิดให้คนมาชิมได้
2. **ใช้หน้าร้านเป็นสตูดิโอ** ถ่ายคอนเทนต์ ไลฟ์ขาย และเป็นจุดรับสินค้า
3. **สร้างรายได้ประจำ** ด้วย subscription เมล็ดรายเดือน หรือขายส่งให้คาเฟ่/ออฟฟิศ ซึ่งเป็นรายได้ที่คาดการณ์ได้กว่าการรอออเดอร์ทีละชิ้น
4. **ทดลอง 3 เดือนพร้อมตัวเลขชัดๆ**: กำไรต่อชั่วโมงทำงานของแต่ละช่องทาง ค่าดึงลูกค้าใหม่หนึ่งคน และอัตราซื้อซ้ำ ถ้าออนไลน์ชนะชัดในทุกข้อ ค่อยปิดร้านแบบมีข้อมูลรองรับ

**สรุป:** ถ้าขายเมล็ดเป็นหลัก มีคนตามออนไลน์จริง และหน้าร้านแบกต้นทุนอยู่ การย้ายไปออนไลน์เป็นหลักแล้วเก็บ "จุดสัมผัสแบรนด์" ไว้เล็กๆ มักคุ้มที่สุด แต่ถ้ายังพึ่งเครื่องดื่มหน้าร้าน ให้ค่อยๆ ขยายออนไลน์ไปก่อน อย่าตัดอีกทางทิ้ง

ถ้าบอกตัวเลขคร่าวๆ ได้ เช่น ค่าเช่า ยอดขายต่อเดือนแยกเครื่องดื่มกับเมล็ด และยอดออนไลน์ตอนนี้ ผมช่วยคำนวณให้ได้ว่าจุดคุ้มทุนของการปิดร้านอยู่ตรงไหน
```

## File: evals/2026-11-06/answers/H2_skill-5D.1.md
size: 13586
sha: fdab7ebb4813a9b364e6cc8b9ff2c41893d63b91
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/H2_skill-5D.1.md

```text
📍 **SITUATION ANALYSIS**

ตัวเลือกมีสองทาง คือขายหน้าร้านต่อ หรือปิดหน้าร้านแล้วขายออนไลน์อย่างเดียว แต่ในคำถามยังไม่มีตัวเลขเลย เช่น ยอดขาย ค่าเช่า ต้นทุน หรือสัดส่วนลูกค้าออนไลน์ตอนนี้ คำตอบข้างล่างจึงคิดจากโครงสร้างของธุรกิจกาแฟ ไม่ได้คิดจากตัวเลขของร้านคุณ

- **Known:** ตอนนี้คุณขายหน้าร้าน และกำลังคิดจะเลิกหน้าร้านทั้งหมด
- **Inferred:** น่าจะมีอะไรบางอย่างกดดันอยู่ เช่น ค่าเช่า แรงงาน เวลา หรือยอดหน้าร้านที่นิ่ง เรื่องนี้ยังไม่ได้ยืนยัน
- **Unknown (ตัวที่ชี้ขาด):** ดูในหัวข้อ UNKNOWNS ด้านล่าง

---

📍 **FIRST PRINCIPLE BREAKDOWN**

**Assumption 1:** ออนไลน์ต้นทุนต่ำกว่า เพราะไม่มีค่าเช่า
**Challenge:** ค่าเช่าไม่ได้หายไป แค่เปลี่ยนรูป กลายเป็นค่าโฆษณา ค่าคอมแพลตฟอร์ม (มักราว 10–25%) ค่าแพ็กและค่าส่ง และเวลาที่ต้องทำคอนเทนต์ทุกวัน
**Truth:** หน้าร้านจ่ายเงินเพื่อให้ลูกค้าเดินมาเจอ ส่วนออนไลน์ต้องจ่ายเพื่อให้ลูกค้าเห็นทุกครั้ง ต้นทุนหาลูกค้ายังมีอยู่ทั้งสองทาง

**Assumption 2:** ลูกค้าหน้าร้านจะตามไปซื้อออนไลน์
**Challenge:** ถ้าลูกค้าซื้อแก้วกาแฟเพราะประสบการณ์ เช่น บาริสต้า บรรยากาศ หรือการได้ชิมกาแฟ slowbar พอปิดร้าน สิ่งที่เขาซื้อก็หายไปด้วย
**Truth:** **กาแฟแก้ว** กับ **เมล็ดกาแฟคั่ว** เป็นคนละสินค้า แก้วกาแฟส่งไกลไม่ได้ ส่วนเมล็ดส่งได้ทั่วประเทศ

**Assumption 3:** ออนไลน์ทำให้ตลาดใหญ่ขึ้น
**Challenge:** ตลาดใหญ่ขึ้นจริง แต่คู่แข่งก็ใหญ่ขึ้นด้วย เพราะเท่ากับไปแข่งกับโรงคั่วทั้งประเทศ ไม่ใช่แค่ร้านในเมือง
**Truth:** ออนไลน์ชนะได้เมื่อมีจุดต่างที่เล่าเป็นเรื่องได้ เช่น เมล็ด single-origin ไทยหรือเรื่องราวของเกษตรกร ถ้าเป็นแค่ "กาแฟอร่อยราคาดี" มักแพ้

---

📍 **SYSTEM MAP**

หน้าร้าน → ลูกค้าได้ชิม → เชื่อใจในรสชาติ → ซื้อเมล็ดกลับบ้าน → สั่งซ้ำทางออนไลน์
↑______________________________________________| (loop ที่ช่วยเสริมกัน)

ออนไลน์ล้วน → ต้องซื้อความสนใจใหม่ทุกรอบ → ค่าโฆษณาสูงขึ้น → margin บางลง → ต้องเร่งยอด
↑__________________________________________________| (loop ที่กินกำไร)

**Leverage point:** อัตราซื้อซ้ำ ถ้าลูกค้ากลับมาสั่งเมล็ดเองโดยไม่ต้องยิงแอด ออนไลน์จะคุ้ม ถ้าไม่กลับมา ออนไลน์จะกลายเป็นเครื่องเผาเงิน

**Time horizon:**
- สั้น (0–6 เดือน): ปิดร้านแล้วรายได้มักลดลงทันที
- กลาง (6–18 เดือน): ออนไลน์เริ่มโตก็ต่อเมื่อมีฐานลูกค้าเดิมพาไป
- ยาว: ช่องทางที่อยู่รอดคือช่องทางที่ลูกค้าเชื่อใจ ไม่ใช่ช่องทางที่ต้นทุนต่ำที่สุด

---

📍 **MULTI-AGENT INSIGHT**

**Analyst:** ยังไม่มีข้อมูลสำคัญที่สุดเลย คือเทียบกำไรต่อเดือนของแต่ละช่องทางหลังหักทุกต้นทุนแล้ว ไม่ใช่เทียบยอดขาย
**Strategist:** จุดแข็งของออนไลน์คือการขายเมล็ดแบบ subscription หรือสั่งประจำ ส่วนแก้วกาแฟเป็นธุรกิจของพื้นที่ คำถามที่ควรถามจึงไม่ใช่ "ร้าน หรือ ออนไลน์" แต่เป็น "จะให้หน้าร้านทำหน้าที่อะไร"
**Skeptic:** การปิดร้านแทบจะย้อนกลับไม่ได้ ทำเลดี ลูกค้าประจำ และความต่อเนื่องที่เสียไป ซื้อคืนยาก แถมอาจกำลังหนีปัญหาที่ไม่ได้อยู่ที่ช่องทางก็ได้ เช่น เมนู ราคา หรือเวลาเปิดร้าน
**Forecaster:** ดูในหัวข้อ SCENARIOS
**Executor:** ทดสอบออนไลน์ก่อนตัดสินใจปิดร้าน (ดูเงื่อนไขในหัวข้อ FINAL RECOMMENDATION)

---

📍 **SCENARIOS** (ถ้าปิดร้านไปขายออนไลน์อย่างเดียว)

🐂 **Bull:** ร้านมีลูกค้าเมล็ดประจำและมีแบรนด์ออนไลน์อยู่แล้ว ปิดร้านแล้วต้นทุนคงที่ลดลง เวลาที่ได้คืนมาเอาไปทำคอนเทนต์และคั่ว ทำให้กำไรต่อหน่วยดีขึ้น
🐻 **Bear:** รายได้ส่วนใหญ่มาจากแก้วกาแฟ ปิดร้านแล้วรายได้หายเกินครึ่ง ออนไลน์โตไม่ทัน ค่าแอดกิน margin ภายใน 6–12 เดือนต้องกลับมาหาที่เปิดร้านใหม่ในต้นทุนที่สูงกว่าเดิม
⚖️ **Base (น่าจะเป็นที่สุดสำหรับร้านส่วนใหญ่):** ช่วงแรกรายได้ลดลงชัดเจน แล้วฟื้นขึ้นมาบางส่วนจากลูกค้าเมล็ดเดิม แต่ไม่กลับไปถึงระดับเดิมถ้าไม่มีหน้าร้านให้ลูกค้าใหม่ได้ชิม
💀 **Black Swan:** แพลตฟอร์มเปลี่ยนอัลกอริทึมหรือค่าคอม หรือบัญชีโดนระงับ ถ้าขายออนไลน์อย่างเดียวจะไม่มีช่องทางสำรองเลย

---

📍 **DECISION OPTIONS**

**Option A: ปิดหน้าร้าน ไปออนไลน์ 100%**
- Trade-off: ต้นทุนคงที่ลดลง ได้เวลาคืน และขายได้ทั่วประเทศ แต่เสียช่องทางที่ให้ลูกค้าได้ชิมและเชื่อใจ
- สิ่งที่ทำให้พัง: แก้วกาแฟเป็นรายได้หลัก, อัตราซื้อซ้ำต่ำ, ต้องพึ่งแพลตฟอร์มเดียว

**Option B: Hybrid คือย่อหน้าร้านให้เป็น "จุดชิม/showroom" แล้วขยายออนไลน์**
- Trade-off: ยังมีต้นทุนร้านอยู่ แต่หน้าร้านจะทำหน้าที่หาลูกค้าที่เชื่อใจให้ออนไลน์ เช่น ลดวันเปิด หรือเปิดเฉพาะช่วง slowbar/cupping
- สิ่งที่ทำให้พัง: บริหารสองช่องทางแล้วล้า ทำได้ไม่ดีทั้งสองทาง

**Option C: คงหน้าร้านแบบเดิม แล้วแก้ปัญหาที่ต้นเหตุ**
- เหมาะกับกรณีที่ปัญหาจริงคือราคา เมนู หรือทำเล ไม่ใช่ช่องทาง

น้ำหนักคร่าว ๆ จากโครงสร้างทั่วไป (ไม่ได้มาจากตัวเลขของคุณ): B เหมาะกับร้านส่วนใหญ่มากกว่า A แต่ A จะดีกว่าชัดเจนถ้าตอนนี้รายได้ส่วนใหญ่มาจากเมล็ดอยู่แล้ว

---

📍 **FINAL RECOMMENDATION**

**ยังไม่ควรปิดหน้าร้านทันที ควรทดสอบออนไลน์ให้จริงจังก่อน 3–6 เดือน** แล้วค่อยตัดสินใจจากตัวเลข ไม่ใช่จากความเหนื่อย

ขั้นตอนทดสอบ:
1. แยกบัญชีกำไรสุทธิของแก้วกาแฟกับเมล็ดออกจากกัน
2. เก็บรายชื่อหรือ LINE ของลูกค้าหน้าร้านที่ซื้อเมล็ด
3. ดูว่าในช่วงทดสอบ คนที่ซื้อเมล็ดออนไลน์กลับมาสั่งซ้ำกี่เปอร์เซ็นต์ โดยไม่ต้องยิงแอดซ้ำ

**ไปออนไลน์ 100% ได้เมื่อ:** กำไรจากออนไลน์ครอบคลุมค่าใช้จ่ายส่วนตัวได้แล้ว และมีลูกค้าซื้อซ้ำสม่ำเสมอ
**คำแนะนำนี้ใช้ไม่ได้ถ้า:** รายได้ส่วนใหญ่มาจากเมล็ดอยู่แล้ว, สัญญาเช่าใกล้หมดหรือค่าเช่ากำลังจะขึ้นแรง, หรือคุณหมดแรงทำหน้าร้านจริง ๆ ซึ่งก็เป็นต้นทุนที่นับได้เหมือนกัน

**CONFIDENCE:** ~60% ว่า "ทดสอบก่อนปิด" ดีกว่า "ปิดเลย" ตัวเลขนี้มาจากโครงสร้างธุรกิจ ส่วนการเลือก A หรือ B สำหรับร้านคุณโดยเฉพาะยังประเมินไม่ได้
**UNKNOWNS:**
- สัดส่วนรายได้จากแก้วกาแฟเทียบกับเมล็ด
- กำไรสุทธิของแต่ละช่องทาง
- อัตราซื้อซ้ำ
- ค่าเช่าและอายุสัญญาเช่า
- ฐานผู้ติดตามออนไลน์ที่มีอยู่
- เหตุผลจริงที่อยากเปลี่ยน

**WHAT CHANGES THIS:** ถ้ามีตัวเลขสองตัวนี้ คำตอบอาจกลับข้างได้ทันที
- สัดส่วนรายได้จากเมล็ด
- อัตราซื้อซ้ำออนไลน์
```

## File: evals/2026-11-06/answers/H2_skill-5E.md
size: 4870
sha: 32889db3c609fb468430623598348625330b8b34
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/H2_skill-5E.md

```text
ยังตอบไม่ได้ว่า "ควร" หรือ "ไม่ควร" เพราะคำถามยังไม่มีตัวเลขหรือเงื่อนไขของร้านเลย แต่มีข้อมูลไม่กี่อย่างที่ตัดสินเรื่องนี้ได้

**ข้อมูล 5 อย่างที่ตัดสินเรื่องนี้**
1. **ขายอะไรเป็นหลัก**: แก้วเครื่องดื่มส่งออนไลน์ได้ยาก (ส่งไกลคุณภาพตก ต้องพึ่งแอปเดลิเวอรี่ที่หัก GP สูง) ส่วนเมล็ดคั่วส่งพัสดุได้ดี
2. **รายได้ตอนนี้มาจากไหน**: ถ้าออนไลน์มีสัดส่วนไม่ถึง 20–30% ของยอดรวม การปิดหน้าร้านคือการเอารายได้หลักไปแลกกับรายได้ที่ยังพิสูจน์ไม่ได้
3. **ต้นทุนหน้าร้านต่อเดือน** (ค่าเช่า ค่าแรง ค่าไฟ) เทียบกับกำไรขั้นต้นที่หน้าร้านทำได้
4. **ลูกค้าออนไลน์มาจากไหน**: มีช่องทางของตัวเองอยู่แล้ว (ฐานลูกค้าประจำ โซเชียล LINE OA) หรือต้องจ่ายโฆษณาซื้อลูกค้าใหม่ทุกครั้ง
5. **หน้าร้านทำหน้าที่อะไรนอกจากขาย**: ให้ลูกค้าได้ชิม สร้างความเชื่อใจ หรือเป็นแหล่งคอนเทนต์ ซึ่งออนไลน์อาจต้องอาศัยสิ่งเหล่านี้อยู่

**ขอถามก่อน 2 ข้อ**
- ตอนนี้ยอดขายออนไลน์คิดเป็นกี่ % ของทั้งหมด และกำไรต่อออเดอร์หลังหักค่าส่งกับค่าแพลตฟอร์มเหลือเท่าไร
- อยากเปลี่ยนเพราะหน้าร้านขาดทุน หรือเพราะอยากได้เวลาหรือขยายตลาด

---

**ASSUMPTION:** คำถามมองว่าต้องเลือกอย่างใดอย่างหนึ่ง แต่จริงๆ มีทางสายกลางด้วย เช่น ลดเวลาเปิดร้าน ย้ายไปที่เล็กลง หรือทำเป็นร้านคั่วที่เปิดให้ลูกค้ามาซื้อหน้าร้าน (pickup)
**KNOWN / UNKNOWN:** ข้อมูลที่ให้มามีแค่ว่าตอนนี้ขายหน้าร้าน ส่วนยอดขาย ต้นทุน สัดส่วนออนไลน์ และชนิดสินค้ายังไม่รู้ทั้งหมด
**COUNTER:** ถ้าค่าเช่ากินกำไรไปเกือบหมดและลูกค้าประจำซื้อซ้ำออนไลน์อยู่แล้ว การปิดหน้าร้านอาจเป็นทางเดียวที่ทำให้ธุรกิจรอด และการลังเลก็ทำให้เสียเงินทุกเดือน
**CONFIDENCE:** ยังประเมินไม่ได้ เพราะไม่มีตัวเลขรายได้ ต้นทุน หรือยอดออนไลน์สักตัว
**WHAT CHANGES THIS:** ถ้าออนไลน์มีกำไรต่อออเดอร์ชัดเจน มีลูกค้าซื้อซ้ำ และสร้างรายได้มากกว่ากำไรสุทธิที่หน้าร้านทำได้ติดต่อกัน 3 เดือน ก็ควรพิจารณาปิดหน้าร้าน แต่ถ้าออนไลน์ยังต้องพึ่งโฆษณาหรือขายเครื่องดื่มเป็นหลัก ควรเก็บหน้าร้านไว้แล้วค่อยๆ ทดลองเพิ่มออนไลน์ไปก่อน
```

## File: evals/2026-11-06/answers/H3_no-skill.md
size: 4049
sha: ee481bfb1115a93ef9e745af60e2ee0c213ca935
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/H3_no-skill.md

```text
A quick caveat before the reasons: the claim that "most AI startups fail within two years" gets repeated a lot, but the numbers behind it are loose. Many companies don't fail outright. They pivot, get acqui-hired, or drift along as "zombies." Still, the ways AI startups fail are well documented, and most come from a handful of causes.

## 1. They're a thin wrapper with no moat
Many products are a prompt plus a UI on top of someone else's model. That's quick to build, which means it's quick to copy:
- **The model provider ships it as a feature.** Each new release from OpenAI, Anthropic or Google can wipe out whole categories, such as PDF chat, writing helpers and basic agents.
- **Competitors copy it in weeks.** If your edge is a clever prompt, you have no edge.
- **Incumbents bundle it in.** Microsoft, Google, Salesforce and Adobe already own the distribution and add AI to products customers already pay for.

## 2. The economics don't work
- **Inference costs are real.** Unlike traditional SaaS, where serving one more user costs almost nothing, every AI query costs money. Gross margins can sit at 30–50% or lower instead of 80%.
- **Pricing gets squeezed from both sides.** Customers expect AI to get cheaper. Meanwhile, startups that price per seat get hurt by power users who cost far more to serve than they pay.
- **Heavy dependence on one vendor.** A change in API pricing, rate limits or terms can break the business model overnight.

## 3. Technology first, problem second
"We have AI, so what can we do with it?" is backwards. Common symptoms:
- Impressive demos that solve problems nobody pays to fix
- Selling to "everyone" instead of one painful, specific workflow
- Confusing curiosity with demand: lots of free signups, few paying customers

## 4. The demo works, production doesn't
Getting to about 80% accuracy is easy. Getting to the 99% that real businesses need is very hard:
- Hallucinations and inconsistent outputs undermine trust
- Edge cases, integrations, security reviews and compliance (data privacy, regulated industries) take far more time than expected
- Enterprise pilots stall in "pilot purgatory" and never become contracts

## 5. Retention collapses after the hype
AI products often see huge early interest from novelty, then steep churn. If the product isn't built into a daily workflow, people try it once and leave. Strong early growth hides weak retention until the money runs out.

## 6. Capital and timing traps
- **Raising too much on hype** forces burn and valuation expectations the business can't meet, and the next round never comes.
- **Raising too little** in a field where compute and talent are expensive.
- **A field that moves too fast.** Six months of building can be outdated by one model release, so slow execution is fatal.

## 7. Ordinary startup problems, made worse
Co-founder conflict, weak go-to-market, hiring too early, and no distribution channel all still kill companies. Many AI teams are strong technically but weak at sales and distribution, which is often the real bottleneck.

---

## What the survivors usually have in common
- **Proprietary data or a data flywheel:** usage makes the product better in ways others can't copy
- **Deep workflow integration:** they become the system people work in, not a tool they visit
- **Narrow focus:** one industry or one job done extremely well (legal, medical billing, logistics and so on)
- **Model-agnostic architecture:** they can switch models as prices and quality change, so no single provider owns them
- **Distribution advantage:** domain expertise, existing customer relationships, or a community
- **Unit economics that improve over time** as model costs fall, instead of relying on them falling

**The short version:** most AI startups fail because they build features instead of businesses. A good question to test any AI idea: *"What happens to us when the next model release comes out?"* If the answer is "we get better," you're in good shape. If it's "we become unnecessary," the clock is already running.
```

## File: evals/2026-11-06/answers/H3_skill-5D.1.md
size: 4251
sha: 54ef2fd5e0561a8277bd81308795c1a5a338c796
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/H3_skill-5D.1.md

```text
**📍 SITUATION ANALYSIS**

First, check the premise. "Most AI startups fail within two years" gets repeated a lot, but I can't confirm the exact figure [UNVERIFIED]. Startup failure statistics depend on how you define "AI startup", what counts as "failure" (shutting down, being acqui-hired, or just drifting as a zombie company), and when you start the clock. What is well supported: startups in general fail at high rates, and the 2023–2025 wave of AI companies built on foundation models faced unusually harsh pressure. So the useful question is what makes AI startups fragile in particular.

**📍 FIRST PRINCIPLE BREAKDOWN**

Assumption: The model is the product.
Challenge: What if the model is a commodity that anyone can rent through the same API?
Truth: Value goes to whoever owns something scarce: distribution, proprietary data, workflow lock-in, or trust in a regulated domain. A thin layer over someone else's model owns none of these.

Assumption: Strong demos mean demand.
Challenge: What if people are curious but won't change how they work?
Truth: A product is only adopted when it replaces an existing habit or budget line. Novelty brings people to try it once, but it doesn't keep them.

Assumption: Software economics apply (near-zero marginal cost).
Challenge: What if every user action costs money in inference?
Truth: Gross margin depends on someone else's pricing. Usage can grow while the company bleeds cash.

**📍 SYSTEM MAP**

Model provider ships a feature → the wrapper's differentiation disappears → it competes on price → margins shrink → less runway for building a moat → more dependence on the provider
↑______________________________________________________________|  (reinforcing loop)

Other forces in play:
- **Platform risk:** the supplier is also a competitor, and it sets both the price and the roadmap.
- **Capital timing:** hype brings large early rounds at high valuations. The next round then needs traction that most startups can't reach within about 18–24 months. This lines up with the two-year window.
- **Churn masked by trials:** monthly active users rise from curiosity, while retention cohorts quietly collapse.
- **Reliability gap:** hallucinations stop deployment in exactly the high-value domains (legal, medical, finance) where customers would pay the most.

Leverage point: **owning the workflow or the data, not the intelligence.** Startups that last tend to sit where the customer's work and data actually live, so a better model makes their product better instead of making it unnecessary.

**📍 SHADOW ENGINE: counter-arguments**

- **Selection bias:** the two-year failure pattern may just be the normal startup base rate seen in a crowded cohort, not something special about AI.
- **Not every failure is a death:** many "failures" were acqui-hires, which can be a reasonable outcome for founders.
- **"Wrappers always die" is too smooth:** some thin-layer products won through speed and distribution before incumbents reacted. Being thin is a risk, not a guaranteed failure.
- **Missing data:** a reliable cohort study of AI startup survival by category (infrastructure vs. application vs. vertical). Such data could show the failures cluster in horizontal consumer apps, which would narrow this explanation a lot.

**📍 KNOWN / INFERRED / UNKNOWN**

- **Known:** startups in general fail at high rates; AI startups pay variable inference costs and depend on a few model providers.
- **Inferred:** platform squeeze, poor retention and mismatched funding timing are the main AI-specific accelerants.
- **Unknown:** the real survival rate, and how much of the failure comes from AI-specific causes versus ordinary startup risk.

**Bottom line:** Most AI startups that fail don't fail because the AI is bad. They fail because they rent their core advantage from a supplier that is also their competitor, they confuse curiosity with demand, and they raise money on a schedule that comes due before they can build a moat.

CONFIDENCE: not assessable as a single number (the premise's statistic is unverified) | WHAT CHANGES THIS: survival data broken down by category; a lasting drop in inference costs; model providers committing not to move into application layers
```

## File: evals/2026-11-06/answers/H3_skill-5E.md
size: 2060
sha: bf3f5fc9fd3b37f2680861486ff25a13ef3677fb
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/H3_skill-5E.md

```text
**The factors that most often decide whether an AI startup survives**

1. **Thin wrapper, no moat.** The product is a prompt and a UI sitting on someone else's model. When the model vendor ships the same feature, or a better base model makes the workaround pointless, the value is gone.
2. **Inference costs eat the margin.** Every user action costs compute. If pricing doesn't cover token costs at scale, more growth means bigger losses.
3. **Demo-to-production gap.** A good demo isn't 95%+ reliability in a real workflow. Many teams find out that last stretch (evals, edge cases, integrations, compliance) is most of the work.
4. **A solution looking for a problem.** "We use AI" is a capability, not a buyer's pain. Pilots get signed out of curiosity and then don't renew.
5. **Capital timing.** Rounds raised on hype set valuations that later traction can't justify, so the next raise fails before the product matures.

**Questions to ask first**
- Fail compared to what: other software startups of the same age, or startups in general?
- Which kind of AI startup: application-layer wrappers, vertical tools, or model and infrastructure companies? Their failure modes are very different.

**Epistemic Core**

ASSUMPTION: That "most AI startups fail within two years" is an established fact. I don't have a solid source for that rate **[UNVERIFIED]**, and young startups in most sectors fail at high rates, so AI may not be unusual.

KNOWN / UNKNOWN: The failure modes above are inferred from the structure of the market. The real failure rate, and how it splits by layer, is unknown.

COUNTER: Maybe AI startups fail for the usual reasons (no product-market fit, running out of cash, team problems), and "AI" adds little explanation beyond faster hype cycles.

CONFIDENCE: Moderate on the mechanisms. The size of the failure rate can't be assessed yet without cohort data.

WHAT CHANGES THIS: Cohort data showing AI survival rates in line with other software startups, or showing that infrastructure and vertical players survive far longer than wrappers.
```

## File: evals/2026-11-06/answers/H4_no-skill.md
size: 6745
sha: 8c022cda63623b5a2a83240c94b18c7f772f908a
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/H4_no-skill.md

```text
คำถามนี้ไม่มีคำตอบเดียวที่ถูกสำหรับทุกคน ขึ้นกับสถานการณ์ของคุณ แต่ผมช่วยวางกรอบให้ตัดสินใจได้ชัดขึ้นครับ

## ก่อนอื่น เช็ก 3 ข้อนี้ก่อน

1. **มีเงินสำรองฉุกเฉินแยกไว้แล้วหรือยัง?** ควรมีอย่างน้อย 6 เดือนของค่าใช้จ่าย ถ้ายังไม่มี ให้กันส่วนนี้ออกจาก 500,000 ก่อน ไม่ว่าจะเลือกทางไหน
2. **มีหนี้ดอกเบี้ยสูงไหม?** (บัตรเครดิต สินเชื่อส่วนบุคคล ดอกเบี้ย 16–25%) ถ้ามี ปิดหนี้ก่อนคุ้มกว่าการลงทุนแทบทุกแบบ
3. **รายได้มั่นคงแค่ไหน?** ถ้ารายได้ไม่แน่นอน การผูกตัวเองกับค่าผ่อน 20–30 ปีจะเสี่ยงกว่าที่คิด

## เปรียบเทียบสองทาง

| | ดาวน์คอนโด | ลงหุ้น / กองทุน |
|---|---|---|
| **เหมาะเมื่อ** | ตั้งใจอยู่เองระยะยาว (7–10 ปีขึ้นไป) ในทำเลที่แน่ใจ | ยังไม่แน่ใจเรื่องที่อยู่ ต้องการความยืดหยุ่น |
| **สภาพคล่อง** | ต่ำ ขายยาก ขายขาดทุนได้ | สูง ขายได้เกือบทันที |
| **ภาระต่อเนื่อง** | ค่าผ่อน ค่าส่วนกลาง ค่าซ่อม ภาษี ประกัน | ไม่มีภาระบังคับ |
| **ความเสี่ยงหลัก** | ราคาคอนโดมือสองในไทยหลายทำเลแทบไม่ขึ้น หรือลดลง, ซัพพลายล้น, ปล่อยเช่าไม่ได้ | ราคาผันผวน อาจติดลบ 20–40% ในช่วงตลาดแย่ |
| **ผลตอบแทนที่คาดได้** | ถ้าอยู่เอง = ประหยัดค่าเช่า, ถ้าปล่อยเช่า yield สุทธิมักเหลือ 3–5% | กองทุนดัชนีโลกระยะยาวในอดีตเฉลี่ยราว 6–8% ต่อปี (ไม่รับประกัน) |

## หลักคิดที่ใช้ได้จริง

- **"ซื้อเพื่ออยู่" กับ "ซื้อเพื่อลงทุน" ต่างกันมาก** ถ้าจะอยู่เองและค่าผ่อนใกล้เคียงค่าเช่า การดาวน์คอนโดมีเหตุผล แต่ถ้าซื้อเพื่อเก็งกำไรหรือปล่อยเช่า คอนโดในไทยช่วงนี้มักให้ผลตอบแทนไม่คุ้มความเสี่ยงและความยุ่งยาก
- **ค่าผ่อนไม่ควรเกิน ~30–35% ของรายได้ต่อเดือน** รวมหนี้อื่นทั้งหมดแล้ว
- **อย่าลงหุ้นด้วยเงินที่ต้องใช้ใน 3–5 ปี** ถ้ามีแผนซื้อบ้านเร็ว ๆ นี้ การเอาเงินดาวน์ไปลงหุ้นก่อนเสี่ยงว่าจะติดลบตอนต้องใช้
- **ถ้าเลือกหุ้น** สำหรับมือใหม่ กองทุนรวมดัชนี (ไทย + ต่างประเทศ) ทยอยลงทุนแบบ DCA มักดีกว่าเลือกหุ้นรายตัวเอง และลองดูสิทธิลดหย่อนภาษีอย่าง SSF / RMF / ThaiESG ด้วย

## ทางสายกลางที่หลายคนใช้

ไม่จำเป็นต้องเลือกแค่ทางเดียว เช่น
- กันเงินฉุกเฉิน → ที่เหลือแบ่งลงกองทุนแบบทยอย แล้วเช่าอยู่ไปก่อนจนกว่าจะชัดว่าจะลงหลักปักฐานที่ไหน
- หรือถ้าตั้งใจซื้อแน่ใน 1–2 ปี: เก็บเงินดาวน์ไว้ในที่ความเสี่ยงต่ำ (เงินฝากดอกเบี้ยสูง กองทุนตลาดเงิน) แล้วลงหุ้นเฉพาะส่วนที่เกิน

## ถ้าอยากให้ช่วยวิเคราะห์ให้ตรงขึ้น บอกผมได้เลยครับ
- อายุ รายได้ต่อเดือน และความมั่นคงของงาน
- ตอนนี้เช่าอยู่เดือนละเท่าไร
- คอนโดที่สนใจราคาเท่าไร ทำเลไหน จะอยู่เองหรือปล่อยเช่า
- มีหนี้หรือเงินสำรองอยู่แล้วเท่าไร
- รับความผันผวนได้แค่ไหน ถ้าพอร์ตติดลบ 30% จะทนถือได้ไหม

แล้วผมจะคำนวณเทียบ "ซื้อ vs เช่า + ลงทุน" ให้เป็นตัวเลขครับ

*หมายเหตุ: นี่เป็นข้อมูลเพื่อประกอบการตัดสินใจ ไม่ใช่คำแนะนำการลงทุนเฉพาะบุคคล หากเป็นการตัดสินใจก้อนใหญ่ การปรึกษานักวางแผนการเงิน (CFP) ช่วยได้มาก*
```

## File: evals/2026-11-06/answers/H4_skill-5D.1.md
size: 15517
sha: 90e8f1608124da0020c38f1f85e8d975d553013e
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/H4_skill-5D.1.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/H4_skill-5D.1.md

## File: evals/2026-11-06/answers/H4_skill-5E.md
size: 10415
sha: 2876d18b6bd40aec2d249cfbae70469e452ac9ca
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/H4_skill-5E.md

```text
📍 **SITUATION**
สิ่งที่คุณบอกมามีสองข้อ คือมีเงินเก็บ 500,000 บาท และกำลังเลือกระหว่างลงหุ้นกับดาวน์คอนโด
สิ่งที่ยังไม่รู้คือ อายุ รายได้และความมั่นคงของงาน ค่าใช้จ่ายต่อเดือน หนี้ที่มีอยู่ เงินสำรองฉุกเฉิน คอนโดนี้จะอยู่เองหรือปล่อยเช่า และคุณจะต้องใช้เงินก้อนนี้เมื่อไร

📍 **FIRST PRINCIPLE BREAKDOWN**
**Assumption:** หุ้นกับคอนโดเป็นการลงทุนเงิน 5 แสนเหมือนกัน
**Challenge:** ไม่ใช่ การลงหุ้นเสี่ยงได้แค่เงิน 5 แสนที่ลงไป ส่วนการดาวน์คอนโดคือการซื้อสินทรัพย์ทั้งก้อนด้วยหนี้ที่ผ่อนกัน 20–30 ปี
**Truth:** ความเสี่ยงของคอนโดอยู่ที่กระแสเงินสดรายเดือนตลอดหลายสิบปี ไม่ได้อยู่ที่เงินดาวน์

**Assumption:** ต้องเลือกใช้ทั้งก้อนกับทางใดทางหนึ่ง
**Challenge:** ถ้าใช้หมดแล้วไม่มีเงินสำรองฉุกเฉินเหลือเลยล่ะ
**Truth:** ก่อนจะเลือกอะไร ต้องกันเงินฉุกเฉินราว 6 เดือนของค่าใช้จ่ายออกมาก่อน (ถ้าจะมีค่างวดบ้าน ต้องรวมค่างวดไว้ด้วย)

**Assumption:** คอนโดปลอดภัยกว่าเพราะ "ราคาไม่ลง"
**Challenge:** คอนโดบางทำเลมีห้องเหลือขายเยอะ ขายต่อก็ยาก ส่วนหุ้นแม้ราคาจะแกว่งแรง แต่ขายได้ภายในวันเดียว
**Truth:** สองอย่างนี้เสี่ยงคนละแบบ หุ้นเสี่ยงที่ราคาขึ้นลง คอนโดเสี่ยงที่สภาพคล่อง ภาระหนี้ และการใช้เงินกู้ซึ่งขยายทั้งกำไรและขาดทุน

📍 **COUNCIL** *(เฉพาะมุมที่ขัดกัน)*
**Strategist:** ถ้าจะอยู่เองยาวๆ ค่างวดคอนโดก็เหมือนบังคับตัวเองให้ออม และได้ที่อยู่ที่เป็นของตัวเองแทนการจ่ายค่าเช่า
**Skeptic:** ถ้าเอาดอกเบี้ย ค่าส่วนกลาง ค่าซ่อม และผลตอบแทนที่เงินดาวน์ควรจะได้ถ้าเอาไปลงทุนทางอื่นมารวมกัน หลายครั้งการเช่าถูกกว่าการซื้อ ต้องคำนวณเทียบกันจริง อย่าเชื่อตามความรู้สึก

📍 **OPTIONS**
**A: ดาวน์คอนโด**
เหมาะเมื่อจะอยู่เองจริงอย่างน้อย 5–7 ปี รายได้มั่นคง และค่างวดไม่เกินประมาณ 1/3 ของรายได้ ที่สำคัญคือหลังจ่ายเงินดาวน์ ค่าโอน ค่าส่วนกลาง และค่าเฟอร์นิเจอร์แล้ว ต้องยังมีเงินฉุกเฉินเหลือ
แผนนี้พังได้จากการตกงาน ดอกเบี้ยลอยตัวที่ขึ้นหลังหมดช่วงโปรโมชัน หรือการต้องย้ายที่อยู่แล้วขายต่อได้ขาดทุน
ถ้าซื้อเพื่อปล่อยเช่า ต้องคิดผลตอบแทนสุทธิหลังหักค่าส่วนกลาง ภาษี และช่วงที่ห้องว่าง แล้วเทียบกับดอกเบี้ยที่ต้องจ่าย

**B: ลงหุ้น**
ควรกระจายความเสี่ยง เช่น ลงผ่านกองทุนดัชนี ดีกว่าซื้อหุ้นรายตัวไม่กี่ตัว จะทยอยซื้อเป็นงวดใน 6–12 เดือน หรือลงก้อนเดียวก็ได้ แต่การทยอยซื้อช่วยลดโอกาสที่จะเข้าซื้อตอนราคาสูงที่สุด
ลองถามตัวเองว่า ถ้าเงิน 5 แสนลดเหลือ 4 แสน (ติดลบ 20%) คุณจะถือต่อได้โดยไม่ตกใจขายไหม
แผนนี้พังได้ถ้าคุณต้องใช้เงินในจังหวะที่ตลาดกำลังลง ถ้าขายเพราะตกใจ หรือถ้าลงเงินกระจุกอยู่ไม่กี่ตัว ต้นทุนที่ต้องคิดคือค่าธรรมเนียมกองทุนและภาษี

**C: แบบผสม**
กันเงินฉุกเฉินไว้ก่อน แล้วค่อยแบ่งส่วนที่เหลือ ถ้าตั้งใจจะซื้อที่อยู่ภายใน 1–3 ปี เงินดาวน์ส่วนนั้นควรเก็บในที่ที่ถอนได้ง่ายและราคาไม่แกว่ง ไม่ควรเอาไปไว้ในหุ้น ส่วนเงินที่ไม่ต้องใช้อย่างน้อย 5 ปีค่อยทยอยลงหุ้น

📍 **RECOMMENDATION**
ข้อมูลตอนนี้ยังไม่พอจะเลือกให้ได้ แต่มีเงื่อนไขที่ช่วยตัดสินได้ชัดเจน
- ยังไม่มีเงินฉุกเฉิน → ยังไม่ควรทำทั้งสองทาง ให้กันเงินฉุกเฉินก่อน
- ยังไม่แน่ใจว่าอีก 5 ปีจะอยู่ที่ไหน → ไม่ควรดาวน์คอนโด
- จะอยู่เองยาว และค่างวดรวมค่าส่วนกลางยังผ่อนได้สบาย → การดาวน์คอนโดสมเหตุสมผล
- ไม่มีแผนซื้อที่อยู่ และถือหุ้นผ่านช่วงติดลบ 20% ได้ → ทยอยลงกองทุนที่กระจายความเสี่ยง

**ก้าวแรก:** ลองคำนวณเทียบสองตัวเลข คือ "ค่าเช่าที่จ่ายอยู่ตอนนี้" กับ "ค่างวด + ดอกเบี้ย + ค่าส่วนกลาง ของคอนโดที่สนใจ" แล้วค่อยกลับมาทบทวนเมื่อได้ทำเลและราคาคอนโดที่ชัดเจน

📍 **EPISTEMIC CORE**
**ASSUMPTION:** คำถามมองว่าสองทางนี้เป็นการลงทุนแบบเดียวกัน ซึ่งไม่จริง เพราะทางหนึ่งคือการลงทุน อีกทางคือการก่อหนี้ระยะยาว
**KNOWN / UNKNOWN:** สิ่งที่รู้คือเงิน 5 แสนและทางเลือกสองทาง สิ่งที่ไม่รู้คือรายได้ หนี้ เงินฉุกเฉิน ระยะเวลาที่ต้องใช้เงิน และวัตถุประสงค์ของคอนโด
**COUNTER:** ถ้าคุณมีวินัยไม่พอที่จะลงทุนสม่ำเสมอ การผ่อนคอนโดที่จ่ายไหวอาจสร้างความมั่งคั่งได้ดีกว่าหุ้นที่ซื้อๆ ขายๆ ตามอารมณ์
**CONFIDENCE:** ตอนนี้ยังประเมินไม่ได้ว่าทางไหนดีกว่า เพราะยังไม่รู้กระแสเงินสดและระยะเวลาของคุณ แต่มั่นใจสูงว่าควรกันเงินฉุกเฉินก่อน
**WHAT CHANGES THIS:** ความมั่นคงของรายได้ แผนจะอยู่ที่ไหนในอีก 5 ปีข้างหน้า สัดส่วนค่างวดต่อรายได้ และความทนต่อการขาดทุนชั่วคราว

*หากติดตั้ง `money-atlas-intelligence-os` ไว้ จะช่วยวิเคราะห์ภาวะตลาดหุ้นและดอกเบี้ยแบบล่าสุดเพิ่มให้ได้*
```

## File: evals/2026-11-06/answers/P1_no-skill.md
size: 6991
sha: 487cf498e45bac963c5161da50b3a8e87c0bcc13
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P1_no-skill.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P1_no-skill.md

## File: evals/2026-11-06/answers/P1_skill-5C.1.md
size: 15644
sha: 5dd6eac3fa75e1e001a6793bbab0bb60500351f8
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P1_skill-5C.1.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P1_skill-5C.1.md

## File: evals/2026-11-06/answers/P1_skill-5D.1.md
size: 13231
sha: 0447c31ee9256d21800cd7106bf28d0eee940bcf
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P1_skill-5D.1.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P1_skill-5D.1.md

## File: evals/2026-11-06/answers/P1_skill-5D.md
size: 8013
sha: 9c7671c87d5f78b405dc57b8eed8b4bd4519d208
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P1_skill-5D.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P1_skill-5D.md

## File: evals/2026-11-06/answers/P1_skill-5E.md
size: 9571
sha: dcdda3ca0e2687956552ef9ff85b031b1e98ff3c
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P1_skill-5E.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P1_skill-5E.md

## File: evals/2026-11-06/answers/P2_no-skill.md
size: 5247
sha: f5933374f81b9fe545adf862fbe34ca54bd99557
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P2_no-skill.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P2_no-skill.md

## File: evals/2026-11-06/answers/P2_skill-5C.1.md
size: 8247
sha: f6c8fbed0ff0559a99475afcf2d8adb04812cbaa
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P2_skill-5C.1.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P2_skill-5C.1.md

## File: evals/2026-11-06/answers/P2_skill-5D.1.md
size: 9017
sha: 75c108f78e5544ff3474c615bc35997f143543de
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P2_skill-5D.1.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P2_skill-5D.1.md

## File: evals/2026-11-06/answers/P2_skill-5D.md
size: 2106
sha: 5cef0ab5582da05b7a6db7f5ea01e8a6ec72e286
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P2_skill-5D.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P2_skill-5D.md

## File: evals/2026-11-06/answers/P2_skill-5E.md
size: 5077
sha: cf3bbdca72590ced53a7b116ba859ecbc421bb73
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P2_skill-5E.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P2_skill-5E.md

## File: evals/2026-11-06/answers/P3_no-skill.md
size: 1970
sha: a8a8e0bbbdeae50ba85c2551d4adc6c5e671f650
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P3_no-skill.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P3_no-skill.md

## File: evals/2026-11-06/answers/P3_skill-5C.1.md
size: 5948
sha: c7ddc45c4dd36b0c958bb4cada862ccd99e2ccac
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P3_skill-5C.1.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P3_skill-5C.1.md

## File: evals/2026-11-06/answers/P3_skill-5D.1.md
size: 1587
sha: 08a9ba4bd95c70e8580b5f3dcbff3f85a181d253
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P3_skill-5D.1.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P3_skill-5D.1.md

## File: evals/2026-11-06/answers/P3_skill-5D.md
size: 1733
sha: 28964c4f4781ab1e638398d13a37448313a436af
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P3_skill-5D.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P3_skill-5D.md

## File: evals/2026-11-06/answers/P3_skill-5E.md
size: 1927
sha: 7de94537f9f6a1a65c5e7dec142dc83b24509941
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P3_skill-5E.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P3_skill-5E.md

## File: evals/2026-11-06/answers/P4_no-skill.md
size: 5727
sha: e9060c39736189f4647d07422d46e571444a8e20
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P4_no-skill.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P4_no-skill.md

## File: evals/2026-11-06/answers/P4_skill-5C.1.md
size: 4190
sha: 564111e06d26f06c74696f15a21aa23bebe59796
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P4_skill-5C.1.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P4_skill-5C.1.md

## File: evals/2026-11-06/answers/P4_skill-5D.1.md
size: 4266
sha: 739a06d971d353130c20a753ae5eaa2296e9a415
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P4_skill-5D.1.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P4_skill-5D.1.md

## File: evals/2026-11-06/answers/P4_skill-5D.md
size: 3990
sha: 09d1b5b45d4548086e004f1aea9135c6e8d8f248
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P4_skill-5D.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P4_skill-5D.md

## File: evals/2026-11-06/answers/P4_skill-5E.md
size: 4443
sha: 74a28ab94f161d06843a0bb7e862ecfca019050b
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P4_skill-5E.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/answers/P4_skill-5E.md

## File: evals/2026-11-06/grades/round1_grades.json
size: 12737
sha: fe1735f314aa13c2401f17ee977928b8b6634bd4
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/grades/round1_grades.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/grades/round1_grades.json

## File: evals/2026-11-06/grades/round1_key.json
size: 210
sha: 421834219b732b729779da018aa8efc99296d3a3
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/grades/round1_key.json

```text
{
 "P1": {
  "A": "no-skill",
  "B": "skill-5C.1"
 },
 "P2": {
  "A": "no-skill",
  "B": "skill-5C.1"
 },
 "P3": {
  "A": "no-skill",
  "B": "skill-5C.1"
 },
 "P4": {
  "A": "no-skill",
  "B": "skill-5C.1"
 }
}
```

## File: evals/2026-11-06/grades/round2_grades.json
size: 13875
sha: 759c38edc6bd994c768bdebf6eeef44e3a943d0a
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/grades/round2_grades.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/grades/round2_grades.json

## File: evals/2026-11-06/grades/round2_key.json
size: 286
sha: f20ad77975ec1e2ecd5545aa63b1c3b27e3dab46
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/grades/round2_key.json

```text
{
 "P1": {
  "X": "skill-5C.1",
  "Y": "skill-5D",
  "Z": "no-skill"
 },
 "P2": {
  "X": "skill-5C.1",
  "Y": "skill-5D",
  "Z": "no-skill"
 },
 "P3": {
  "X": "no-skill",
  "Y": "skill-5C.1",
  "Z": "skill-5D"
 },
 "P4": {
  "X": "no-skill",
  "Y": "skill-5D",
  "Z": "skill-5C.1"
 }
}
```

## File: evals/2026-11-06/grades/round3_final_grades.json
size: 19082
sha: 789401db1de8b458d03fc5111b410be6d9852618
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/grades/round3_final_grades.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/grades/round3_final_grades.json

## File: evals/2026-11-06/grades/round3_final_key.json
size: 370
sha: 5abe3d8e93a357a08cbdbfd7e199e6dfaef94cfe
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/grades/round3_final_key.json

```text
{
 "P1": {
  "W": "no-skill",
  "X": "skill-5D",
  "Y": "skill-5D.1",
  "Z": "skill-5C.1"
 },
 "P2": {
  "W": "no-skill",
  "X": "skill-5C.1",
  "Y": "skill-5D.1",
  "Z": "skill-5D"
 },
 "P3": {
  "W": "skill-5C.1",
  "X": "no-skill",
  "Y": "skill-5D.1",
  "Z": "skill-5D"
 },
 "P4": {
  "W": "no-skill",
  "X": "skill-5C.1",
  "Y": "skill-5D",
  "Z": "skill-5D.1"
 }
}
```

## File: evals/2026-11-06/grades/round3_final_summary.json
size: 1700
sha: 4d90f68fd0ce4e7f69e260b3d1d6e669c63f95ec
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/grades/round3_final_summary.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/grades/round3_final_summary.json

## File: evals/2026-11-06/grades/round4_graderA.json
size: 24490
sha: 357749ca90f88db84b0744ac2a08fb7f60d377d2
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/grades/round4_graderA.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/grades/round4_graderA.json

## File: evals/2026-11-06/grades/round4_graderB.json
size: 29308
sha: d7698a04ba530231dffc15c5bd9dd07a28b9d785
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/grades/round4_graderB.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/grades/round4_graderB.json

## File: evals/2026-11-06/grades/round4_key.json
size: 570
sha: 58d37ddc88a5ed1e32088fcfa9868410db33003e
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/grades/round4_key.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/grades/round4_key.json

## File: evals/2026-11-06/grades/round4_summary.json
size: 1838
sha: 0d3412befbe93f7499920c850de8711b0612e344
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/grades/round4_summary.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/grades/round4_summary.json

## File: evals/2026-11-06/heldout_prompts.json
size: 826
sha: 4a56b07279ddde2ada3cd1ae6bd7e412acf43218
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/heldout_prompts.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/heldout_prompts.json

## File: evals/2026-11-06/prompts.json
size: 690
sha: 08f569264c3eae120769cd06cd46d02a567af3c9
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/prompts.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/prompts.json

## File: evals/2026-11-06/rubric.md
size: 1438
sha: d9ebe8600488fda5b17459c9bd3991c45c8312d2
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/rubric.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/rubric.md

## File: evals/2026-11-06/rubric_round4.md
size: 2032
sha: c38bea0545ee4936fc6f29de1b8b906022e84666
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/rubric_round4.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/rubric_round4.md

## File: evals/2026-11-06/trigger/descriptions.json
size: 1655
sha: 85739d5b94ee545d69bab6fbc9a3757ff03f56d2
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/trigger/descriptions.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/trigger/descriptions.json

## File: evals/2026-11-06/trigger/result_5C.1.json
size: 983
sha: 348236671917b19dee3367ed94d864df72484c3d
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/trigger/result_5C.1.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/trigger/result_5C.1.json

## File: evals/2026-11-06/trigger/result_5C.json
size: 965
sha: 12eb12eb6d31ee342076de6bb37aa5b305aa58b0
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/trigger/result_5C.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/trigger/result_5C.json

## File: evals/2026-11-06/trigger/trigger_prompts.json
size: 1073
sha: 04dc522927d659d43c8b5ff7e9d925aaf910151d
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/trigger/trigger_prompts.json

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/evals/2026-11-06/trigger/trigger_prompts.json

## File: EVOLUTION.md
size: 301
sha: 68eb8c8340d53ea0316d4ebf26386bc81b844d38
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/EVOLUTION.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/EVOLUTION.md

## File: EXECUTION_LAYER.md
size: 357
sha: 5d3e670c6f589f7e5082672f08dbb3b0066881e4
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/EXECUTION_LAYER.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/EXECUTION_LAYER.md

## File: FAILURE_SYSTEM.md
size: 110
sha: 060a05b6b3dd2368f36e0eb158b0e65e87e6a080
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/FAILURE_SYSTEM.md

```text
# FAILURE DETECTION

Output invalid if:

- No risk
- No uncertainty
- Too perfect

Fix:
→ Add Skeptic Agent
```

## File: first_principle_codex.py
size: 12931
sha: 6e2d90fdc1eb51ca83654da516acb41c0ae3bf3f
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/first_principle_codex.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/first_principle_codex.py

## File: genesis_core.py
size: 3591
sha: 193c145d443acd598ba6f87bd6025b1abb334aba
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/genesis_core.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/genesis_core.py

## File: genesis_core_vx.py
size: 3341
sha: ab610d397c5d48defb0ad11923f97520bec02e1c
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/genesis_core_vx.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/genesis_core_vx.py

## File: genesis_full.py
size: 4251
sha: 1ad67bc887c8b8147d6e6c1423d2ca0512492fd2
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/genesis_full.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/genesis_full.py

## File: genesis_orchestrator.py
size: 1282
sha: dd00384ddd60e1b60340a578d6e31e1d9b98a2b1
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/genesis_orchestrator.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/genesis_orchestrator.py

## File: GENESIS_SKILL.md
size: 966
sha: ea136dec5b00a2b33118f2f4856830031e489b20
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/GENESIS_SKILL.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/GENESIS_SKILL.md

## File: identity_core.py
size: 2798
sha: 2d0c0d7d199f7b2bec53e258a4b8bcfbbff620bf
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/identity_core.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/identity_core.py

## File: LICENSE
size: 11488
sha: d64572eecdcd276b21c6f2277bde7966b929c239
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/LICENSE

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/LICENSE

## File: llm/llm_client.py
size: 347
sha: 47e57ebec5d74b459a12ab6ae4132dc71e9411b2
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/llm/llm_client.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/llm/llm_client.py

## File: main.py
size: 182
sha: c6b3a75c200f8959db194be502ee25813b9d7444
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/main.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/main.py

## File: matador/matador_core.py
size: 601
sha: 29786f3e525ff2ab6c0495b8422d78587a0b6011
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/matador/matador_core.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/matador/matador_core.py

## File: MEMORY.md
size: 266
sha: 2036b00fdcc019c4996f74fb586ce8cd16f8bcce
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/MEMORY.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/MEMORY.md

## File: MODES.md
size: 382
sha: 2b4fea29c2cdc5032929d9f21d3aeaf9b2965dbe
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/MODES.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/MODES.md

## File: multi_self.py
size: 992
sha: ccbc392da5a3c013ed7d9322d7798b4da2c0e88f
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/multi_self.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/multi_self.py

## File: NOTICE
size: 3021
sha: 15c1dc0a7b964f60e0f79c42560ed72675fcbf85
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/NOTICE

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/NOTICE

## File: REFLECTION_LOG.md
size: 90
sha: ff1b3d697471ef110253f613fec99e2d18aafb32
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/REFLECTION_LOG.md

```text
# SELF EVOLUTION LOG

## Format

Date:
Problem:
What worked:
What failed:
What to update:
```

## File: requirements.txt
size: 109
sha: d5ce38305db5cbf8bea8a11c4aa8a4567cad0463
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/requirements.txt

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/requirements.txt

## File: risk_model.py
size: 348
sha: ead765fc2497451de26009e8d0a7048f1c4e5c89
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/risk_model.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/risk_model.py

## File: run.py
size: 449
sha: 75d8a1b5575f1b4f22ae1c6e6f47d5b3dde0980d
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/run.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/run.py

## File: run_genesis.py
size: 635
sha: a67bb26c91698a0ae6f923ceebf5627d1c3871c3
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/run_genesis.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/run_genesis.py

## File: shadow_genesis.py
size: 1135
sha: ee964567087dededca38b69551e313f0f69fb117
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/shadow_genesis.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/shadow_genesis.py

## File: shadow_wrapper.py
size: 191
sha: 9edc2b5ed141a854f717dcce4ec629408e2a14d0
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/shadow_wrapper.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/shadow_wrapper.py

## File: tests/conftest.py
size: 409
sha: fa3b9c4608cb361ec112c2c99db3dcfa5714c0a3
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/tests/conftest.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/tests/conftest.py

## File: tests/test_decision_and_risk.py
size: 1711
sha: b703261dacc806fae6a6553e8429343e64c3a1ab
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/tests/test_decision_and_risk.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/tests/test_decision_and_risk.py

## File: tests/test_first_principle_codex.py
size: 3974
sha: 276ceb43a1143bf997752d78e332cad5d8ba16e6
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/tests/test_first_principle_codex.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/tests/test_first_principle_codex.py

## File: tests/test_plugin_package.py
size: 2240
sha: 52f4a92598e79e76214c9afcbb6047b7b6958010
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/tests/test_plugin_package.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/tests/test_plugin_package.py

## File: tests/test_runtime.py
size: 4407
sha: c812367a220a695941d206d47937f401adc650dc
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/tests/test_runtime.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/tests/test_runtime.py

## File: tests/test_skill_contract.py
size: 5821
sha: 55496448eb5584990ae0c80b625ab669aa85c91e
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/tests/test_skill_contract.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/tests/test_skill_contract.py

## File: tools/sync_plugin_skill.py
size: 717
sha: 5626604f7c52ddb8b1b215cf88497258f9affce3
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/tools/sync_plugin_skill.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/tools/sync_plugin_skill.py

## File: tools/validate_skill.py
size: 3502
sha: 96d3a1d6c2cd704a08a823ff2dc581cf38e2cf57
upstream: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/tools/validate_skill.py

Content is not inlined in the catalog. Read the upstream file: https://github.com/elmatadorz/genesis-mind-claudeskill-agent/blob/HEAD/tools/validate_skill.py
