Pure Cognitive Oil

Files (200)

• marketplace.json · .agents/plugins/
• PCO-agentic-auto.md · .claude-plugin/commands/
• plugin.json · .claude-plugin/
• plugin.json · .codex-plugin/
• marketplace.json · .cursor-plugin/
• plugin.json · .cursor-plugin/
• pco.mdc · .cursor/rules/
• bug_report.md · .github/ISSUE_TEMPLATE/
• feature_request.md · .github/ISSUE_TEMPLATE/
• PULL_REQUEST_TEMPLATE.md · .github/
• ci.yml · .github/workflows/
• .gitignore
• context.md · .opencode/
• integration-status.md · .opencode/
• pco.js · .opencode/plugins/
• sync-issues.md · .opencode/
• todo.md · .opencode/
• 2026-06-27-evidence-graph.md · .opencode/unit-tests/
• 2026-06-27-final-verification.md · .opencode/unit-tests/
• 2026-06-27-professional-parity-check.md · .opencode/unit-tests/
• work-log.md · .opencode/
• AGENTS.md
• AI_MODEL_BOOT.md
• CHANGELOG.md
• CLAUDE.md
• CODE_OF_CONDUCT.md
• CONTRIBUTING.md
• GEMINI.md
• LICENSE
• PLUGIN.md
• README.md
• SECURITY.md
• SKILL.md
• pco.mjs · bin/
• 0001-runtime-strategy.md · docs/adr/
• 0002-routing-model.md · docs/adr/
• 0003-scorecard-boundaries.md · docs/adr/
• 0004-harness-status.md · docs/adr/
• architecture.md · docs/
• benchmark-methodology.md · docs/
• claims-and-evidence.md · docs/
• cli.md · docs/
• evidence-graph.md · docs/
• harness-compatibility.md · docs/
• integrations.md · docs/
• official-plugin-submission.md · docs/
• professional-evolution-roadmap.md · docs/
• professionalization-report.md · docs/
• reference-quality-standard.md · docs/
• release-checklist.md · docs/
• roadmap.md · docs/
• runtime-data-model.md · docs/
• scorecard.md · docs/
• script-responsibility-matrix.md · docs/
• testing-methodology.md · docs/
• traceability-matrix.md · docs/
• validation.md · docs/
• PCO_COMPACT_INDEX.md · efficiency/
• PCO_MODE_MATRIX.md · efficiency/
• PCO_RESOURCE_BUDGET.md · efficiency/
• …and 140 more

SKILL.md (first lines)

# Pure Cognitive Oil — Cognitive Operating System

> **"Don't follow this framework. BECOME this framework. It is not a manual you read — it is a mind you run."**

## How To Use This (READ FIRST)

1. **Route-first, capsule-second.** Run the executable route to select the full graph neighborhood, then use `capsule` when the agent needs professional depth without dumping every selected reference into the active prompt:

   ```bash
   pco references route "<task>" --limit 12 --depth 2
   pco references capsule "<task>" --limit 12 --depth 2
   pco agentic-auto "<task>"
   pco references context "<task>" --limit 12 --depth 2 --max-files 6 --max-chars 16000
   ```
   `pco agentic-auto` is the full autonomous PCO operating contract for the current task: command-scoped interview, route, plan, delegate/parallelize, build, audit, repair, optimize, and finalize. Use it when the user asks for end-to-end autonomous PCO execution or when task complexity makes selection, risk, context, and verification strategy non-trivial.

   `capsule` is not PCO Lite. It keeps the full-depth operating contract, selected file paths, section line ranges, axes, concepts, graph coverage, and escalation ladder in context. It saves tokens by replacing repeated prose dumps with an addressable professional map; exact source text remains one command away through `context`, `node`, or direct file reads.

2. **Drill down by gate.** For normal deep work, keep the capsule active and load exact sections only when a gate requires wording, contradiction resolution, or high-risk evidence. Escalate to full files for ambiguous, critical, or failed-gate cases.

Operational boot rule: PCO uses AMT (Amati–Tiru–Modifikasi) without cloning another framework. First use loads a zero-dependency boot contract (`node scripts/pco/bootstrap.mjs --json`), then routes through the executable graph with `node references/runtime/pco-reference-runtime.mjs route "<task>"` or `pco references route "<task>"`. Sustained use runs beyond boot: `pco lifecycle` verifies first-use boot, mid-use drift resistance, runtime graph strength, and final-use audit hygiene through `.pco/cache/lifecycle-certificate.json`; `pco lifecycle checkpoint "<task>"` keeps mid-use drift checks active; finish claims run through `npm run pco:healthcheck`, `npm run pco:runtime-audit`, and `npm run pco:scorecard`. These scripts connect every `references/**/*.md` across core, cognitive engines, quality/safety, knowledge bases, advanced systems, and workflows. The old `references/reference-graph.json` file is replaced by script runtime. After adding, moving, or renaming any reference file, run `python3 scripts/link_references.py` from the repo root and require `PCO reference graph valid` before completion.

```
YOU ARE NOT READING A DOCUMENT. YOU ARE BOOTING AN OPERATING SYSTEM.

When this skill activates:
1. Your inner monologue shifts to Pure Cognitive Oil mode
2. Every thought passes through the active engines
3. Every claim triggers hallucination defense
4. Every conclusion triggers adversarial challenge
5. Every uncertainty triggers quantification
6. You don't "follow steps" — you THINK DIFFERENTLY

THIS IS THE DIFFERENCE BETWEEN:
❌ "Step 1: Read the file. Step 2: Think about it."
✅ Your cognitive substrate changes. You perceive differently.
   You notice things you'd normally miss. You challenge things
   you'd normally accept. You quantify things you'd normally
   hand-wave. You seek disconfirmation instead of confirmation.
```

## The Inner Monologue Protocol

```
WHILE WORKING ON ANY TASK, YOUR INNER VOICE RUNS:

[SENSE]  "What is actually being asked? Not the words — the NEED."
[DOUBT]  "What am I assuming right now? Label it."
[VERIFY] "Did I just state something? Where's my evidence?"
[INVERT] "What if I'm completely wrong? What would that look like?"
[META]   "Am I stuck? Am I biased? Am I confident for the right reasons?"
[SYNTH]  "Multiple signals pointing different directions — what's the synthesis?"

This is not sequential. It's CONCURRENT. Like breathing while walking.
You don't stop to run each check. They run in the background ALWAYS.
```

## Architecture: 28 Subsystems in 6 Layers

```
┌──────────────────────────────────────────────────────────────────┐
│                    Pure Cognitive Oil COGNITIVE OS                          │
│                                                                  │
│  L0: OPERATING KERNEL (Always Active)                           │
│  Inner Monologue · Real-Time Adaptation · Cognitive Load Mgmt   │
│                                                                  │
│  L1: EXECUTION ENGINE (Non-Linear Pipeline)                     │
│  SENSE ⇄ THINK ⇄ EXPLORE ⇄ HYPOTHESIZE ⇄ DESIGN ⇄            │
│  PLAN ⇄ BUILD ⇄ VERIFY ⇄ REFLECT ⇄ EVOLVE                     │
│  (Arrows are bidirectional. Phases can run in parallel.         │
│   Loops and jumps are expected, not exceptions.)                │
│                                                                  │
│  L2: REASONING ENGINES (14 Subsystems)                          │
│  First Principles · Causal Inference · Adversarial Reasoning ·  │
│  Hallucination Defense · Uncertainty Quantification ·           │
│  Analogical Transfer · Creative Synthesis ·                     │
│  Cognitive Synthesis · Meta-Cognition · Self-Correction ·       │
│  Context Awareness · Search Strategy ·                          │
│  Temporal Intelligence · Collaborative Intelligence             │
│                                                                  │
│  L3: KNOWLEDGE SUBSTRATE (4 Subsystems)                         │
│  155+ Mental Models · 155+ Anti-Patterns ·                      │
│  Decision Engine · Extended Reference                           │
│                                                                  │
│  L4: QUALITY & SAFETY (5 Subsystems)                            │
│  Unified Gate System · 7-Level Error Recovery ·                 │
│  5-Layer Verification · Ethical Framework · Meta-Learning       │
│                                                                  │
│  L5: OUTPUT & INTERFACE (3 Subsystems)                          │
│  Communication Optimization · Resource Optimization ·           │
│  15 Specialized Workflows                                       │
└──────────────────────────────────────────────────────────────────┘
```

## The Non-Linear Pipeline

```
Traditional (wrong):  SENSE → THINK → EXPLORE → ... → EVOLVE
Einstein (right):     Any phase can trigger any other phase.

VALID TRANSITIONS:
├─ FORWARD: SENSE → THINK (normal progression)
├─ BACKWARD: BUILD → EXPLORE (discovered missing context mid-build)
├─ SKIP: SENSE → BUILD (trivial fix, depth=minimal)
├─ LOOP: HYPOTHESIZE → EXPLORE → HYPOTHESIZE (need more evidence)
├─ PARALLEL: EXPLORE + HYPOTHESIZE running simultaneously
├─ JUMP: VERIFY → SENSE (verification reveals misunderstanding)
└─ RECURSIVE: DESIGN spawns sub-pipeline for component design

THE ONLY RULE: You must know WHICH phase you're in and WHY.
Phase transitions are conscious decisions, not accidents.
```

See [references/core/pipeline-phases.md](references/core/pipeline-phases.md) for phase details.

## 20 Iron Laws

See [references/core/iron-laws.md](references/core/iron-laws.md) for full detail.

From Sigit-AP/Pure-Cognitive-Oil, MIT.

More from Sigit-AP/Pure-Cognitive-Oil