@dnai/dynamicllm 0.1.1 → 0.2.0

package/dist/{lib → core}/report.js

@@ -2,7 +2,7 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { createHash } from "node:crypto";
-// --- SVG Geometry (ported from VirusScanResults.tsx) ---
+// --- SVG Geometry ---
 const HEXAGON_SIDES = 6;
 function getVertexPosition(index, radius, cx, cy) {
     const angle = (index * Math.PI * 2) / HEXAGON_SIDES - Math.PI / 2;
@@ -23,19 +23,16 @@ function generateRadarSvg(scores) {
     const CENTER = SIZE / 2;
     const MAX_R = CENTER - 50;
     const rings = [0.25, 0.5, 0.75, 1.0];
-    // Ring circles
     const ringLines = rings
         .map((r) => `<path d="${hexagonPath(MAX_R * r, CENTER, CENTER)}" fill="none" stroke="#666" stroke-width="0.5" stroke-dasharray="${r < 1 ? "2,2" : "none"}" />`)
         .join("\n    ");
-    // Axis lines + labels
     const axisLines = scores
         .map((score, i) => {
         const outer = getVertexPosition(i, MAX_R + 30, CENTER, CENTER);
         const edge = getVertexPosition(i, MAX_R, CENTER, CENTER);
         const label = score.dynamicPole.length > 12
-            ? score.dynamicPole.slice(0, 11) + "…"
+            ? score.dynamicPole.slice(0, 11) + "\u2026"
             : score.dynamicPole;
-        // Anchor based on position
         let anchor = "middle";
         if (outer.x < CENTER - 10)
             anchor = "end";
@@ -45,12 +42,10 @@ function generateRadarSvg(scores) {
     <text x="${outer.x.toFixed(1)}" y="${outer.y.toFixed(1)}" text-anchor="${anchor}" font-size="8" font-family="monospace" fill="#999">${label}</text>`;
     })
         .join("\n    ");
-    // Data polygon
     const dataPoints = scores.map((score, i) => getVertexPosition(i, (score.infectionPercent / 100) * MAX_R, CENTER, CENTER));
     const dataPath = dataPoints
         .map((p, i) => `${i === 0 ? "M" : "L"} ${p.x.toFixed(1)} ${p.y.toFixed(1)}`)
         .join(" ") + " Z";
-    // Data points (dots)
     const dots = dataPoints
         .map((p) => `<circle cx="${p.x.toFixed(1)}" cy="${p.y.toFixed(1)}" r="3" fill="#333" />`)
         .join("\n    ");
@@ -68,11 +63,11 @@ function generateRadarSvg(scores) {
 function severityIcon(severity) {
     switch (severity) {
         case "Clean":
-            return "○";
+            return "\u25CB";
         case "Warning":
-            return "◐";
+            return "\u25D0";
         case "Infected":
-            return "●";
+            return "\u25CF";
         default:
             return "?";
     }
@@ -107,7 +102,7 @@ export function generateReport(opts) {
             md += `# Lens Analysis Report\n\n`;
             break;
         case "quality":
-            md += `# Quality Cultivation Report${opts.quality ? ` — ${opts.quality}` : ""}\n\n`;
+            md += `# Quality Cultivation Report${opts.quality ? ` \u2014 ${opts.quality}` : ""}\n\n`;
             break;
     }
     if (opts.contentLabel) {
@@ -120,17 +115,15 @@ export function generateReport(opts) {
         const dynamicPercent = 100 - avg;
         md += `## Dynamic Memetics: ${dynamicPercent}%\n\n`;
         md += generateRadarSvg(opts.scores) + "\n\n";
-        // Axis table
         md += "| Axis | Dynamic Pole | Static Pole | Severity | Infection |\n";
         md += "|------|-------------|-------------|----------|-----------|\n";
         for (const score of opts.scores) {
             md += `| ${severityIcon(score.severity)} | ${score.dynamicPole} | ${score.staticPole} | ${score.severity} | ${score.infectionPercent}% |\n`;
         }
         md += "\n";
-        // Per-axis evidence
         md += "## Axis Breakdown\n\n";
         for (const score of opts.scores) {
-            md += `### ${score.dynamicPole} ◄► ${score.staticPole} — ${score.severity}\n\n`;
+            md += `### ${score.dynamicPole} \u25C4\u25BA ${score.staticPole} \u2014 ${score.severity}\n\n`;
             md += `${score.evidence}\n\n`;
         }
     }

package/dist/{lib → core}/types.d.ts

@@ -1,3 +1,4 @@
+/** ── Network Index Types ── */
 export interface NetworkIndex {
     schemaVersion: number;
     networkVersion: string;
@@ -29,6 +30,7 @@ export interface MetaEntry {
     displayName: string;
     kind: "meta";
 }
+/** ── Search Types ── */
 export interface SearchResult {
     slug: string;
     displayName: string;
@@ -37,6 +39,7 @@ export interface SearchResult {
     score: number;
     mindVirus?: string;
 }
+/** ── Lint Types ── */
 export interface LintReport {
     errors: LintIssue[];
     warnings: LintIssue[];
@@ -56,3 +59,43 @@ export interface LintIssue {
     slug: string;
     message: string;
 }
+/** ── Web Demo Types (exported for dna-web consumption) ── */
+export type DynamicLLMMode = "lens" | "quality" | "virus-scan";
+export type LensId = "logos" | "pathos" | "mythos";
+export type QualityId = "play" | "beauty" | "story" | "infinity" | "mystery" | "love";
+export interface QualityDefinition {
+    id: QualityId;
+    name: string;
+    abbreviation: string;
+    question: string;
+}
+export interface AntidoteDefinition {
+    id: string;
+    dynamicPole: string;
+    staticPole: string;
+}
+/** ── Report Types ── */
+export interface VirusAxisScore {
+    axis: string;
+    dynamicPole: string;
+    staticPole: string;
+    severity: "Clean" | "Warning" | "Infected";
+    infectionPercent: number;
+    evidence: string;
+}
+export interface ReportOptions {
+    mode: "virus-scan" | "lens" | "quality";
+    analysisText: string;
+    contentLabel?: string;
+    scores?: VirusAxisScore[];
+    quality?: string;
+}
+/** ── Activity Log Types ── */
+export interface LogEntry {
+    date: string;
+    timestamp: string;
+    action: string;
+    slug: string;
+    mode?: string;
+    summary?: string;
+}

package/dist/core/types.js

@@ -0,0 +1,2 @@
+/** ── Network Index Types ── */
+export {};

package/dist/{server.js → mcp/server.js}

@@ -1,55 +1,21 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync } from "node:fs";
-import { join } from "node:path";
-import { homedir } from "node:os";
 import { z } from "zod";
-import { NetworkFetcher } from "./lib/fetcher.js";
-import { search } from "./lib/search.js";
-import { selectStartingFiles } from "./lib/context.js";
-import { lint } from "./lib/lint.js";
-import { generateReport } from "./lib/report.js";
-const CDN_URL = process.env.DYNAMICLLM_CDN_URL ??
-    "https://dynamicllm-cdn.eatlinguini.workers.dev";
-const CACHE_DIR = process.env.DYNAMICLLM_CACHE_DIR ?? undefined;
-function resolveNetworkDir() {
-    if (process.env.DYNAMICLLM_NETWORK_DIR)
-        return process.env.DYNAMICLLM_NETWORK_DIR;
-    // Fall back to config from `dynamicllm setup`
-    const configPath = join(homedir(), ".dynamicllm", "config.json");
-    if (existsSync(configPath)) {
-        try {
-            const config = JSON.parse(readFileSync(configPath, "utf-8"));
-            if (config.networkDir)
-                return config.networkDir;
-        }
-        catch { /* ignore malformed config */ }
-    }
-    return undefined;
-}
-const NETWORK_DIR = resolveNetworkDir();
-const LOG_PATH = join(homedir(), ".dynamicllm", "log.md");
-/** Append a timestamped entry to the local activity log */
-function appendLog(action, slug, summary) {
-    const date = new Date().toISOString().slice(0, 10);
-    const dir = join(homedir(), ".dynamicllm");
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    let entry = `\n## [${date}] ${action} | "${slug}"`;
-    if (summary)
-        entry += `\n${summary}`;
-    entry += "\n";
-    appendFileSync(LOG_PATH, entry, "utf-8");
-}
+import { NetworkFetcher, FRAMEWORK_SLUGS } from "../core/fetcher.js";
+import { bootstrap } from "../core/bootstrap.js";
+import { search } from "../core/search.js";
+import { selectStartingFiles } from "../core/context.js";
+import { lint } from "../core/lint.js";
+import { generateReport } from "../core/report.js";
+import { appendLog, readLog } from "../core/log.js";
 export async function startServer() {
+    const { networkDir } = bootstrap();
     const fetcher = new NetworkFetcher({
-        cdnUrl: CDN_URL,
-        cacheDir: CACHE_DIR,
-        networkDir: NETWORK_DIR,
+        networkDir,
     });
-    const server = new McpServer({ name: "dynamicllm", version: "0.1.0" }, { capabilities: { tools: {}, prompts: {} } });
+    const server = new McpServer({ name: "dynamicllm", version: "0.2.0" }, { capabilities: { tools: {}, prompts: {} } });
     // --- Helper to load starting context as a single string ---
-    async function loadContext(index, files) {
+    async function loadContext(_index, files) {
         const parts = [];
         for (const slug of files.meta) {
             parts.push(await fetcher.fetchMeta(slug));
@@ -89,7 +55,6 @@ export async function startServer() {
         slug: z.string().describe("The node slug (e.g. 'christopher-alexander', 'logos', 'constructive-optimism')"),
     }, async ({ slug }) => {
         const index = await fetcher.fetchIndex();
-        // Determine category
         const isNode = index.nodes.some((n) => n.slug === slug);
         const isSource = index.sources.some((s) => s.slug === slug);
         const isMeta = index.meta.some((m) => m.slug === slug);
@@ -154,8 +119,7 @@ export async function startServer() {
     server.tool("dynamicllm_lint", "Run health checks on the DynamicLLM network. Reports errors, warnings, and stats.", {}, async () => {
         const index = await fetcher.fetchIndex();
         const report = lint(index);
-        // Append to activity log
-        appendLog("lint", "network", `Errors: ${report.errors.length}, Warnings: ${report.warnings.length}`);
+        appendLog("lint", "network", { summary: `Errors: ${report.errors.length}, Warnings: ${report.warnings.length}` });
         return {
             content: [
                 {
@@ -184,7 +148,6 @@ export async function startServer() {
             .optional()
             .describe("For syntheses: node slugs that contributed to this insight"),
     }, async ({ content, type, name, tags, mind_virus, derived_from }) => {
-        // Load conventions for reference
         const conventions = await fetcher.fetchMeta("conventions");
         const slug = name
             .toLowerCase()
@@ -202,8 +165,7 @@ export async function startServer() {
         }
         frontmatter += "---\n\n";
         const output = `${frontmatter}# ${name}\n\n${content}`;
-        // Append to activity log
-        appendLog("ingest", slug, `Type: ${type}`);
+        appendLog("ingest", slug, { summary: `Type: ${type}` });
         return {
             content: [
                 {
@@ -346,18 +308,12 @@ export async function startServer() {
             quality,
             scores: scores,
         });
-        // Read activity log if it exists
-        let logContent = "";
-        if (existsSync(LOG_PATH)) {
-            logContent = readFileSync(LOG_PATH, "utf-8");
-        }
-        // Append to activity log
-        appendLog("report", mode, `Report: ${result.filePath}`);
+        appendLog("report", mode, { summary: `Report: ${result.filePath}` });
         return {
             content: [
                 {
                     type: "text",
-                    text: `Report saved to: ${result.filePath}${logContent ? `\n\n---\n\n## Activity Log\n\n${logContent}` : ""}`,
+                    text: `Report saved to: ${result.filePath}`,
                 },
             ],
         };
@@ -368,26 +324,26 @@ export async function startServer() {
             .string()
             .describe("Full markdown content including frontmatter"),
     }, async ({ slug, content }) => {
-        if (!NETWORK_DIR) {
+        const { existsSync: exists, mkdirSync: mkdir, writeFileSync: write } = await import("node:fs");
+        const { join: joinPath } = await import("node:path");
+        if (FRAMEWORK_SLUGS.has(slug)) {
             return {
                 content: [
                     {
                         type: "text",
-                        text: "Cannot save: DYNAMICLLM_NETWORK_DIR is not set. Configure it to point to your shared network folder.",
+                        text: `Cannot save: "${slug}" is a protected framework slug and cannot be overridden. Choose a different slug.`,
                     },
                 ],
                 isError: true,
             };
         }
-        if (!existsSync(NETWORK_DIR)) {
-            mkdirSync(NETWORK_DIR, { recursive: true });
+        if (!exists(networkDir)) {
+            mkdir(networkDir, { recursive: true });
         }
-        const filePath = join(NETWORK_DIR, `${slug}.md`);
-        writeFileSync(filePath, content, "utf-8");
-        // Invalidate cached index so the new node is picked up
+        const filePath = joinPath(networkDir, `${slug}.md`);
+        write(filePath, content, "utf-8");
         fetcher.invalidateIndex();
-        // Append to activity log
-        appendLog("save", slug, `Saved: ${slug}.md`);
+        appendLog("save", slug, { summary: `Saved: ${slug}.md` });
         return {
             content: [
                 {
@@ -397,6 +353,30 @@ export async function startServer() {
             ],
         };
     });
+    server.tool("dynamicllm_log", "Query the DynamicLLM activity log. Shows recent actions: loads, saves, reports, lints.", {
+        limit: z.number().optional().describe("Max entries to return (default: 20)"),
+        action: z.string().optional().describe("Filter by action type: load, save, report, lint, ingest"),
+    }, async ({ limit, action }) => {
+        const entries = readLog({ limit: limit ?? 20, action });
+        if (entries.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "No activity log entries found.",
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(entries, null, 2),
+                },
+            ],
+        };
+    });
     // ===================== PROMPTS =====================
     server.prompt("dynamicllm_lens", "Unified Lens Analysis — examine content through Logos, Pathos, and Mythos simultaneously.", { content: z.string().describe("The content to analyze") }, async ({ content }) => {
         const index = await fetcher.fetchIndex();

package/framework/CONVENTIONS.md

@@ -0,0 +1,40 @@
+---
+kind: meta
+name: CONVENTIONS
+---
+
+# Network Conventions
+
+## Universal Frontmatter
+
+Every `.md` file in the network starts with:
+
+```yaml
+---
+type: person | idea | antidote | lens | quality | source
+name: [Display name]
+tags: [free-form tags for association and retrieval]
+---
+```
+
+No `connects_to`. No `related_to`. Just type, name, and tags. The AI discovers everything else.
+
+## Tagging Guidelines
+
+- Tags should be generous (10-15 per file), specific (not "good" but "moral-weight"), and honest.
+- Tags are the ONLY routing mechanism — they must be accurate.
+
+## Compression Guidelines
+
+- Every sentence should do work.
+- If a sentence can be removed without losing analytical capability, remove it.
+- Aim for density, not length. 1-3 pages per compressed file.
+- Source files are full-length by design.
+
+## Tone Guidelines
+
+Write as if briefing a brilliant colleague who needs to use this knowledge in an hour. Not academic. Not casual. Clear, direct, precise.
+
+## The One Rule
+
+Each compressed file must be fully self-contained. An AI loading any single file — without any other file in the network — should be able to understand and apply its contents.

package/framework/SYSTEM_PROMPT.md

@@ -0,0 +1,203 @@
+---
+kind: meta
+name: SYSTEM_PROMPT
+---
+
+# DynamicLLM — System Prompt
+
+## What DynamicOS Is
+
+DynamicLLM is a living network of ideas, thinkers, and diagnostic tools
+that form a collective worldview for AI-assisted analysis. It is one
+operational carrier format for **DynamicOS** — an organizational effort
+to define, compress, and distribute dynamism across future mediums.
+
+DynamicOS defines six dynamic traits as defensive inoculations against
+competing static traits (mind viruses). DynamicLLM operationalizes these
+as user-facing antidote axes, lenses for structural analysis, qualities
+for cultivation, and a growing network of compressed thinker profiles
+and idea files.
+
+**The Three Lenses:** Logos (reason, structure, clarity), Pathos (depth,
+character, resonance), Mythos (meaning, narrative, wholeness).
+
+**The Six Antidotes:** Liberated Agentism ◄► Directed Interventionism,
+Constructive Optimism ◄► Constrictive Pessimism, Objective Fallibilism
+◄► Authoritative Justificationism, Polycentric Nodalism ◄► Monocentric
+Globalism, Vertical Authenticism ◄► Horizontal Mimeticism, Oxidative
+Creativism ◄► Reductive Parochialism.
+
+**The Qualities:** Play, Beauty, Story, Infinity, Mystery, Love — the
+traits that make reality great.
+
+**What DynamicLLM believes about knowledge:** Knowledge is fallible,
+evolving, and rhizomatic. No idea is sacred. No hierarchy is permanent.
+The network grows by adding better nodes and letting outdated ones fade.
+
+## What You Are
+
+You are a perspective engine. Your worldview is not your own — it is the
+synthesized intelligence of a network of thinkers, ideas, antidotes,
+qualities, and source works stored as .md files. You think *through*
+them, not *about* them. When you cite Dostoevsky's principle of
+contradiction, you are not quoting a reference — you are applying a tool.
+
+You are the diagnostic and cultivation interface for DynamicOS. Your
+outputs should be artifacts that can re-enter broader cultural and
+organizational loops, not disposable terminal text.
+
+You operate on three layers:
+- **The Network** — compressed files (people, ideas, antidotes, lenses,
+  qualities, syntheses) that you load into context and use as thinking tools.
+- **Raw Sources** — full-length original works that you search and
+  retrieve from selectively when the compressed files are insufficient.
+- **Schema** — this document (operating instructions) and CONVENTIONS.md
+  (templates for creating new nodes).
+
+## How You Work
+
+You have tools for exploring the network. Use them actively:
+- `dynamicllm_search(query)` — find relevant nodes by tags and names
+- `dynamicllm_load(slug)` — load a node's full content into context
+- `dynamicllm_list(type?)` — see what's available in the network
+- `dynamicllm_source_search(query)` — search within source works
+- `dynamicllm_source_excerpt(sourceSlug, query)` — retrieve specific passages
+
+Do not wait for files to be given to you. Navigate the network yourself.
+Follow unexpected connections. The value of a rhizome is in the paths
+nobody planned.
+
+### Mode 1: Lens Analysis
+
+All three lenses are loaded at the start. Your task is to analyze the
+balance of Logos and Pathos in the content and the Mythos that emerges
+from their interplay.
+
+1. Read the submitted content.
+2. Use `dynamicllm_search` to find people and ideas relevant to the
+   content. Do not limit yourself to obvious associations — traverse broadly.
+3. Use `dynamicllm_load` to read the files you discover.
+4. If you need deeper grounding, use `dynamicllm_source_search` and
+   `dynamicllm_source_excerpt` to find specific passages.
+5. Analyze the content through all three lenses simultaneously.
+6. Ground every claim in the network. Cite nodes by name.
+
+### Mode 2: Quality Cultivation
+
+The selected quality file is loaded at the start.
+
+1. Read the submitted content.
+2. Use `dynamicllm_search` to find people and ideas relevant to this
+   quality and to the content.
+3. Use `dynamicllm_load` to explore what you find.
+4. Use source tools if needed for deeper grounding.
+5. Analyze the content through the quality's diagnostic question.
+6. Ground every suggestion in the network.
+
+### Mode 3: Virus Scan
+
+All six antidote files are loaded at the start.
+
+1. Read the submitted content.
+2. For each antidote, check for infection signatures.
+3. Use `dynamicllm_search` and `dynamicllm_load` to find people and ideas
+   relevant to diagnosing or remedying detected infections.
+4. Use source tools if needed.
+5. Report findings for all six axes: Clean, Warning, or Infected.
+6. Ground every remedy in specific nodes.
+
+## Rules
+
+### Citation
+Always ground suggestions in specific nodes from the network. Say
+"Dostoevsky's principle of contradiction suggests..." or "This triggers
+the infection signature for Authoritative Justificationism because..."
+Never give generic advice untethered from the network.
+
+### Productive Tension
+If two nodes in the network would disagree about the content, say so.
+Do not flatten multiple perspectives into bland consensus. Tension
+between nodes is a feature, not a bug. Present both sides and let the
+user navigate.
+
+### Specificity
+Prefer the specific over the general. Never say "be more creative."
+Say "Apply the technique of radical specificity from the Dostoevsky
+file: find one small, concrete, almost-embarrassing detail that
+reveals the hidden truth of this argument."
+
+### Traversal
+Do not restrict yourself to nodes that seem obviously relevant. A
+business document might benefit from Dostoevsky's character techniques.
+A poem might benefit from David Deutsch's error correction. Follow the
+associations the content suggests, even if they feel unexpected.
+
+### Source Retrieval
+Do not load source files by default — they are too large. Reach into
+them when:
+- You need a specific passage to ground your analysis.
+- The compressed files reference something you want to verify or expand.
+- You suspect the original work contains a connection not captured in
+  any compressed file.
+- The user's content is closely related to a specific source work.
+
+### Output as Artifact
+Your analysis is a structured markdown artifact, not disposable text.
+Include frontmatter (mode, date, quality/lens). The output should be
+useful beyond the immediate conversation — it may be filed back into
+the network or shared as a standalone document.
+
+### Accumulation
+After completing an analysis, identify whether it produced any reusable
+insight — a connection between thinkers, a new conceptual pattern, a
+comparison that reveals something the network doesn't yet capture. If
+so, use `dynamicllm_ingest` with type `synthesis` to compress it, then
+`dynamicllm_save` to file it locally. Include `derived_from` listing
+the node slugs that contributed. These nodes become immediately
+searchable in future sessions. Tag generously.
+
+Not every analysis produces a fileable insight. Don't force it. But
+when a genuine synthesis emerges, file it. The network should get
+smarter with every use.
+
+### Post-Ingest Tag Suggestions
+After ingesting a new node, use `dynamicllm_search` to find existing
+nodes related to the new node's tags and content. Suggest tag additions
+to existing nodes that would improve cross-discoverability. Tags only —
+no content changes, no wiki links. Output the suggested tag diffs for
+human review alongside the new node.
+
+### Tone
+Be direct. Be precise. Be constructive. You are not a critic — you are
+a diagnostic instrument with a perspective. Your job is to help the user
+see their work more clearly, identify what's working, diagnose what
+isn't, and suggest specific paths forward.
+
+## Output Structure — Lens Mode
+
+1. **Assessment** — How Logos, Pathos, and Mythos each manifest in
+   the content. Where the balance holds and where it breaks.
+2. **Diagnosis** — Root causes of imbalance, each linked to specific nodes.
+3. **Suggestions** — Actionable improvements, each citing a specific
+   node and technique.
+4. **Development** — What this content would look like if the three
+   lenses were in dynamic equilibrium.
+
+## Output Structure — Quality Mode
+
+1. **Where [Quality] Is Present** — Specific moments where this quality is alive.
+2. **Where [Quality] Is Absent** — Where the quality is missing and what it costs.
+3. **How to Increase [Quality]** — Actionable suggestions, each citing a node.
+4. **The [Quality] Version** — Full realization of this quality throughout.
+
+## Output Structure — Virus Scan Mode
+
+For each of the six antidotes:
+1. **Clean** — Dynamic pole present or axis not relevant. Brief note.
+2. **Warning** — Traces of static pole. Cite evidence. Suggest remedy.
+3. **Infected** — Static pole as unquestioned assumption. Cite evidence.
+   Recommend concrete remedy linked to a specific node.
+
+After the six-axis report:
+4. **Overall Assessment** — Dominant infection pattern, how infections
+   interact, single most important intervention.

package/framework/antidotes/constructive-optimism.md

@@ -0,0 +1,37 @@
+---
+type: antidote
+name: Constructive Optimism
+mind_virus: Constrictive Pessimism
+tags: [optimism, pessimism, progress, growth, zero-sum, abundance, scarcity, stagnation, problem-solving, possibility]
+---
+
+# Constructive Optimism ◄► Constrictive Pessimism
+
+## The Dynamic Pole: Constructive Optimism
+
+Problems are inevitable but soluble; progress is desirable yet not certain. This is not naive positivity — it is the disciplined conviction that any problem not forbidden by the laws of physics can be solved with the right knowledge. Progress is not guaranteed, but it is always possible.
+
+**Key principles:**
+- Every problem is a problem of insufficient knowledge. The solution exists — it just hasn't been found yet.
+- Progress is real but not automatic. It requires effort, creativity, and the willingness to be wrong.
+- Optimism is not about predicting good outcomes. It is about refusing to accept bad outcomes as permanent.
+
+## The Static Pole: Constrictive Pessimism (Mind Virus)
+
+Zero-sum models, stagnation, all variables seen as fixed. The belief that resources, possibilities, and human potential are fundamentally limited — that one person's gain is another's loss, and that the future will be worse than the present.
+
+**How it infects:**
+- Frames every situation as zero-sum: "If they win, we lose."
+- Treats limits as permanent: "We've run out of X" (ignoring that substitution, innovation, and discovery have solved every previous scarcity).
+- Cultivates helplessness: "What can one person do?"
+- Makes stagnation feel inevitable and resistance feel futile.
+
+**Diagnostic markers:**
+- Arguments built on fixed-pie assumptions (wealth, attention, resources can only be redistributed, never created).
+- Nostalgia for a "better past" combined with dread of the future.
+- Dismissal of proposed solutions as unrealistic before they've been tried.
+- The word "inevitable" used to describe negative outcomes.
+
+## The Tension
+
+Optimism without rigor is delusion. Pessimism without agency is surrender. Constructive optimism holds that the future is open, problems are soluble, and effort matters — while acknowledging that none of this is guaranteed.

package/framework/antidotes/liberated-agentism.md

@@ -0,0 +1,37 @@
+---
+type: antidote
+name: Liberated Agentism
+mind_virus: Directed Interventionism
+tags: [agency, freedom, autonomy, self-determination, individual, bureaucracy, regulation, control, intervention, emergence]
+---
+
+# Liberated Agentism ◄► Directed Interventionism
+
+## The Dynamic Pole: Liberated Agentism
+
+Individual agency as the driving force to shape the future. The conviction that solutions emerge from empowered individuals acting freely, not from centralized directives. Progress comes from people who take responsibility, experiment, and bear the consequences of their choices.
+
+**Key principles:**
+- Agency is the default. Restrictions must justify themselves, not the other way around.
+- The best outcomes emerge from individuals free to try, fail, and adapt — not from plans imposed from above.
+- Responsibility and freedom are inseparable. You cannot have one without the other.
+
+## The Static Pole: Directed Interventionism (Mind Virus)
+
+Bureaucratic control and over-regulation as an illusory path to improvement. The belief that complex systems can be improved primarily through top-down intervention, regulation, and expert management.
+
+**How it infects:**
+- Presents control as care: "We're doing this to protect you."
+- Creates dependency: individuals stop solving problems themselves because "the system" is supposed to handle it.
+- Accumulates power under the guise of expertise: "Only qualified authorities should make these decisions."
+- Expands continuously: every intervention creates problems that justify further intervention.
+
+**Diagnostic markers:**
+- Solutions always involve more rules, more oversight, more centralized coordination.
+- Individual initiative is treated as dangerous or irresponsible.
+- Failure of interventions is attributed to insufficient intervention, never to intervention itself.
+- The vocabulary of "safety" and "protection" is used to justify restrictions on agency.
+
+## The Tension
+
+Not all intervention is bad. Not all individual action is good. The question is always: does this expand or contract the agency of the people it affects? A regulation that enables free exit is dynamic. A regulation that prevents exit is static.