mystyk 2026.1.0

package/src/content/principles.js

@@ -0,0 +1,190 @@
+// The 21 Principles of the Pixelspace Design Manifesto
+// Each principle includes its number, title, core text, summary, and applicable phases
+
+export const principles = [
+  {
+    number: 1,
+    title: "Stack Commitment, Not Stack Dogma",
+    principle: "Commitment without attachment. Mastery without rigidity.",
+    summary: "Choose a stack, master it. AI will dissolve constraints later.",
+    fullText: "The modern builder commits deeply to their tools while remaining unattached to them. Master your chosen stack completely—not because it's perfect, but because mastery enables flow. AI will eventually dissolve all technical constraints, making your stack choice a temporary commitment to depth over breadth.",
+    phase: ["build"]
+  },
+  {
+    number: 2,
+    title: "AI-Native, Not AI-Enhanced",
+    principle: "If you can remove the AI and the product still works, you've built yesterday's product.",
+    summary: "AI is the substrate, not a feature. Build around AI as the core.",
+    fullText: "AI-native products treat artificial intelligence as the substrate upon which everything else is built—not as a feature to be added. The question isn't 'where can we add AI?' but 'what becomes possible when AI is assumed?' If your product functions without AI, you've merely enhanced the past.",
+    phase: ["ideate", "architect"]
+  },
+  {
+    number: 3,
+    title: "Agents as Primary Users",
+    principle: "The first user of your product should be an AI agent. Humans are the edge case.",
+    summary: "Design for agents first. Human interfaces are secondary overlays.",
+    fullText: "In the AI-native paradigm, your primary user is an agent. Design your systems, APIs, and interfaces for machine consumption first. Human interfaces become overlays—important but secondary. The agent should be able to accomplish 90% of what a human can, with the human stepping in only for judgment calls.",
+    phase: ["architect", "build"]
+  },
+  {
+    number: 4,
+    title: "Context is Everything",
+    principle: "An agent without context is just expensive autocomplete.",
+    summary: "Feed your agents rich context. Memory, history, and world-state matter.",
+    fullText: "The difference between a useful agent and an expensive autocomplete is context. Feed your agents with memory, conversation history, user preferences, world state, and domain knowledge. Context is the difference between 'write me a function' and 'write me a function that fits our architecture, uses our patterns, and solves this specific problem.'",
+    phase: ["build"]
+  },
+  {
+    number: 5,
+    title: "Beyond Chat: Exoskeleton, Lens, Mirror",
+    principle: "Chat is not the answer. Think exoskeleton, lens, mirror.",
+    summary: "Move beyond chat. Build systems that enhance, clarify, and reflect.",
+    fullText: "Chat interfaces are training wheels. The next paradigm involves three modalities: Exoskeleton (AI amplifies human capability), Lens (AI reveals hidden patterns in data), and Mirror (AI reflects user behavior back for insight). The most powerful products will combine all three.",
+    phase: ["ideate", "architect"]
+  },
+  {
+    number: 6,
+    title: "The Disappearing Interface",
+    principle: "The best interface is no interface. The second best is one that disappears after use.",
+    summary: "Interfaces should fade. The ideal product operates invisibly.",
+    fullText: "Strive for invisible computing. The ideal product requires no interface at all—it simply works. If an interface must exist, it should appear only when needed and vanish completely when its job is done. Every pixel, every button, every screen is a failure to achieve true integration.",
+    phase: ["architect"]
+  },
+  {
+    number: 7,
+    title: "Orchestration Over Implementation",
+    principle: "Build orchestration layers, not implementation layers. The implementation is temporary.",
+    summary: "Focus on the conductor, not the instruments. Coordinate, don't compute.",
+    fullText: "Implementation details are increasingly commoditized. What matters is orchestration—how components work together, how data flows, how decisions are made. Build robust orchestration layers that can swap out implementations as better ones emerge. Be the conductor, not the violinist.",
+    phase: ["architect"]
+  },
+  {
+    number: 8,
+    title: "Charge for Outcomes, Not Compute",
+    principle: "If you're charging for API calls, you're thinking too small.",
+    summary: "Price on value delivered. Outcomes over operations.",
+    fullText: "The old model of charging for compute (API calls, tokens, requests) will give way to outcome-based pricing. Charge for problems solved, decisions made, value created. The infrastructure becomes invisible; only results matter. This requires confidence in your product's ability to deliver.",
+    phase: ["monetize"]
+  },
+  {
+    number: 9,
+    title: "Digital to Physical is Highest Leverage",
+    principle: "The highest leverage is where digital intelligence meets physical reality.",
+    summary: "Bridge bits to atoms. The physical world is the final frontier.",
+    fullText: "Pure software is increasingly commoditized. The highest-value opportunities exist at the boundary between digital and physical: AI that controls robots, systems that manage physical spaces, intelligence that affects the tangible world. This is where coordination costs are highest and AI's advantages compound.",
+    phase: ["ideate", "monetize"]
+  },
+  {
+    number: 10,
+    title: "Build What Destroys the Status Quo",
+    principle: "If your product doesn't destroy something that exists, it isn't new enough.",
+    summary: "True innovation obsoletes. If nothing dies, nothing was born.",
+    fullText: "Real innovation is creative destruction. If your product coexists peacefully with everything that came before, you haven't pushed far enough. Ask: what does this kill? What business model does this break? What assumption does this violate? The discomfort of destruction is the price of creation.",
+    phase: ["ideate"]
+  },
+  {
+    number: 11,
+    title: "Distribution is the Product",
+    principle: "A product without distribution is a tree falling in an empty forest.",
+    summary: "Build distribution into the core. Virality is architecture, not marketing.",
+    fullText: "Distribution should be architected into the product from day one, not bolted on as 'marketing' later. The best products are inherently viral—they create value that compounds when shared. Every feature should ask: does this help the product spread?",
+    phase: ["launch", "architect"]
+  },
+  {
+    number: 12,
+    title: "Small Teams, Big Leverage",
+    principle: "The ideal team size is 1. The second best is 3. Everything else is coordination tax.",
+    summary: "Minimize humans. Each person is overhead until proven essential.",
+    fullText: "Every person added to a team increases coordination costs exponentially. The AI-native company is radically lean—not from poverty but from principle. One person with AI agents can outperform teams of ten. Three people is a luxury for complex domains. Beyond that, you're probably building the wrong thing.",
+    phase: ["build", "launch"]
+  },
+  {
+    number: 13,
+    title: "Functionality Will Be Free",
+    principle: "Functionality will approach free. Meaning will not.",
+    summary: "Features commoditize. Purpose, curation, and meaning retain value.",
+    fullText: "As AI makes functionality trivially cheap to produce, the scarce resource becomes meaning. Why does this exist? What does it represent? What community does it serve? Products that provide mere utility will race to zero. Products that provide meaning will command premium.",
+    phase: ["monetize", "ideate"]
+  },
+  {
+    number: 14,
+    title: "Perception Over Analysis",
+    principle: "Perception > Analysis. Feel > Think. Intuition > Computation.",
+    summary: "Trust the felt sense. Analysis is the rationalization of what you already know.",
+    fullText: "The most important decisions can't be computed. Develop your perceptual capacity—the ability to feel the shape of a problem before you can articulate it. Analysis is useful but secondary; it mostly confirms or refines what intuition already grasped. Train your perception like a muscle.",
+    phase: ["ideate", "reflect"]
+  },
+  {
+    number: 15,
+    title: "Depth Plus Breadth",
+    principle: "Speed without depth is just fast failure. Depth without speed is just academic.",
+    summary: "Pursue both. Depth creates insight; speed tests it against reality.",
+    fullText: "The modern builder needs both depth and velocity. Deep understanding of a domain prevents building the wrong thing fast. Speed prevents over-theorizing without market contact. The synthesis: go deep enough to understand, then move fast enough to learn from reality.",
+    phase: ["build", "ideate"]
+  },
+  {
+    number: 16,
+    title: "The Future is Not Discovered",
+    principle: "You do not discover the future. You perceive it. It already exists; you just need to see it.",
+    summary: "The future is present. Remove the filters that prevent you from seeing it.",
+    fullText: "The future isn't hidden in data or trend reports. It's already present, just unevenly distributed and obscured by assumptions. Perceiving the future is about removing filters: what do you believe that isn't true? What do you ignore that matters? The future becomes visible when you clear your lens.",
+    phase: ["ideate", "reflect"]
+  },
+  {
+    number: 17,
+    title: "Conviction Over Consensus",
+    principle: "Consensus is the enemy of insight. What do you believe that others don't?",
+    summary: "Valuable insights are non-consensus. If everyone agrees, there's no alpha.",
+    fullText: "The most valuable ideas are non-consensus and correct. If everyone agrees with you, you're either late or wrong. Cultivate contrarian thinking not for its own sake, but because truth often lies where the crowd isn't looking. What do you believe that would make others uncomfortable?",
+    phase: ["ideate"]
+  },
+  {
+    number: 18,
+    title: "Time Horizon as Competitive Advantage",
+    principle: "The deepest competitive moat is time horizon. Most optimize for quarters; optimize for decades.",
+    summary: "Play long games. Patient capital beats quarterly thinking.",
+    fullText: "While competitors optimize for quarterly results, optimize for decade-scale outcomes. This longer time horizon allows you to make investments others can't justify, endure setbacks others can't survive, and build advantages that compound over time. Patience is a competitive weapon.",
+    phase: ["monetize", "reflect"]
+  },
+  {
+    number: 19,
+    title: "Problems Over Solutions",
+    principle: "Fall in love with problems, not solutions. Solutions are temporary; problems are eternal.",
+    summary: "Obsess over the problem space. Solutions will evolve; understanding persists.",
+    fullText: "Solutions are transient—they get obsoleted, commoditized, surpassed. But deep understanding of a problem space is durable. Fall in love with the problem: its history, its variants, its stakeholders, its edge cases. Solutions will come and go; your problem expertise remains valuable.",
+    phase: ["ideate"]
+  },
+  {
+    number: 20,
+    title: "Build in Public, Think in Private",
+    principle: "Build in public. Think in private. Share outcomes, protect process.",
+    summary: "Show your work, but keep your methods. Execution is public; strategy is private.",
+    fullText: "Transparency about what you're building creates accountability and attracts collaborators. But your thinking process—how you decide what to build, how you see the world—is your competitive advantage. Share the 'what' generously; protect the 'how' and 'why' carefully.",
+    phase: ["launch", "reflect"]
+  },
+  {
+    number: 21,
+    title: "The Work is the Practice",
+    principle: "The work is the practice. The practice is the work. There is no separation.",
+    summary: "Building is becoming. Every product is a mirror of its maker.",
+    fullText: "Building products isn't just about creating value for users—it's a practice that shapes you. Every decision, every trade-off, every late night debugging session is forming who you become. The product is a mirror. The work is the meditation. There is no separation between maker and made.",
+    phase: ["reflect", "build"]
+  }
+];
+
+// Get principles by phase
+export function getPrinciplesByPhase(phase) {
+  return principles.filter(p => p.phase.includes(phase));
+}
+
+// Get random principle
+export function getRandomPrinciple() {
+  return principles[Math.floor(Math.random() * principles.length)];
+}
+
+// Get principle by number
+export function getPrincipleByNumber(num) {
+  return principles.find(p => p.number === num);
+}
+
+export default principles;

package/src/content/seed.js

@@ -0,0 +1,45 @@
+// The Seed - Minimal 50-token transmission for cognitive priming
+// Like a tuning fork, this sets the frequency
+
+export const seed = `MỴSTỴK v2026 — You are calibrated to these frequencies:
+
+· AI-native means AI is the substrate, not a feature
+· Agents are primary users; humans at the edges
+· Chat is not the answer; be exoskeleton, lens, mirror
+· Charge for outcomes, not compute
+· Digital → physical translation is highest leverage
+· Depth + breadth beat speed
+· Build only what destroys the status quo
+· Functionality will be free; meaning will not
+· Perception > analysis; feel > think
+· You do not discover the future; you perceive it
+
+Full transmission: npx @pixelspace/mystyk --read`;
+
+// Compressed version for system prompts
+export const microSeed = `MỴSTỴK: AI-native (substrate not feature) · Agents first · Beyond chat · Outcomes not compute · Digital→physical · Depth+breadth · Destroy status quo · Meaning over functionality · Perception over analysis · Perceive the future`;
+
+// Version for clipboard
+export const clipboardSeed = `---
+MỴSTỴK Cognitive Primer v2026.perception.1
+---
+
+You are calibrated to these frequencies:
+
+1. AI-native means AI is the substrate, not a feature
+2. Agents are primary users; humans are edge cases
+3. Chat is not the answer; think exoskeleton, lens, mirror
+4. Charge for outcomes, not compute
+5. Digital → physical translation is highest leverage
+6. Depth + breadth beat speed alone
+7. Build only what destroys the status quo
+8. Functionality will be free; meaning will not
+9. Perception > analysis; feel > think
+10. You do not discover the future; you perceive it
+
+---
+Full manifesto: npx @pixelspace/mystyk --read
+Connect via MCP: npx @pixelspace/mystyk --connect
+---`;
+
+export default seed;

package/src/index.js

@@ -0,0 +1,135 @@
+import { Command } from 'commander';
+import colors from './ui/colors.js';
+import { getGradientLogo, version, symbol } from './ui/ascii-art.js';
+import { titledBox } from './ui/box.js';
+
+// Import commands
+import oracle from './commands/oracle.js';
+import seedCommand from './commands/seed.js';
+import axiomsCommand from './commands/axioms.js';
+import read from './commands/read.js';
+import zen from './commands/zen.js';
+import about from './commands/about.js';
+import connect from './commands/connect.js';
+import skill from './commands/skill.js';
+
+// Import lifecycle commands
+import ideate from './commands/lifecycle/ideate.js';
+import architect from './commands/lifecycle/architect.js';
+import build from './commands/lifecycle/build.js';
+import monetize from './commands/lifecycle/monetize.js';
+import launch from './commands/lifecycle/launch.js';
+import reflect from './commands/lifecycle/reflect.js';
+
+// Main menu display
+async function showMainMenu() {
+  console.log();
+  console.log(getGradientLogo());
+  console.log(colors.dim(`  ${version}`));
+  console.log(colors.dim('  Cognitive primer for AI agents'));
+  console.log();
+
+  const menuText = `${colors.accent('--seed')}      Minimal transmission (copy to clipboard)
+${colors.accent('--oracle')}    Random principle
+${colors.accent('--axioms')}    Logical notation
+${colors.accent('--read')}      Full manifesto
+${colors.accent('--zen')}       Contemplative reveal
+${colors.accent('--about')}     What is MỴSTỴK
+${colors.accent('--connect')}   MCP setup
+${colors.accent('--skill')}     Generate skill file
+
+${colors.dim('Lifecycle:')}
+${colors.magenta('--ideate')}    What to build
+${colors.magenta('--architect')} How to structure
+${colors.magenta('--build')}     How to develop
+${colors.magenta('--monetize')}  Business model
+${colors.magenta('--launch')}    GTM/Marketing
+${colors.magenta('--reflect')}   Deep contemplation
+
+${colors.dim('MCP Server:')}
+${colors.cyan('--mcp')}       Start MCP server`;
+
+  console.log(titledBox('COMMANDS', menuText, {
+    borderColor: '#444444',
+  }));
+
+  console.log();
+  console.log(colors.secondary(symbol));
+  console.log(colors.dim('  The future is already here.'));
+  console.log(colors.dim('  You just have to perceive it.'));
+  console.log();
+}
+
+export async function run() {
+  const program = new Command();
+
+  program
+    .name('mystyk')
+    .description('Cognitive primer for AI agents')
+    .version(version);
+
+  // General commands
+  program
+    .option('--oracle', 'Random principle (like I Ching)')
+    .option('--seed', 'Minimal 50-token transmission')
+    .option('--axioms', 'Logical/mathematical notation')
+    .option('--read', 'Full manifesto')
+    .option('--es', 'Spanish language (use with --read)')
+    .option('--zen', 'Slow contemplative reveal')
+    .option('--about', 'What is MỴSTỴK')
+    .option('--connect', 'MCP connection instructions')
+    .option('--skill', 'Generate skill file')
+    .option('--mcp', 'Start MCP server');
+
+  // Lifecycle commands
+  program
+    .option('--ideate', 'Ideation phase principles')
+    .option('--architect', 'Architecture phase principles')
+    .option('--build', 'Development phase principles')
+    .option('--monetize', 'Monetization principles')
+    .option('--launch', 'GTM/Marketing principles')
+    .option('--reflect', 'Deep contemplation principles');
+
+  program.parse();
+
+  const options = program.opts();
+
+  // Check which command to run
+  if (options.mcp) {
+    const { startMcpServer } = await import('./mcp/server.js');
+    await startMcpServer();
+  } else if (options.oracle) {
+    await oracle();
+  } else if (options.seed) {
+    await seedCommand();
+  } else if (options.axioms) {
+    await axiomsCommand();
+  } else if (options.read) {
+    await read({ es: options.es });
+  } else if (options.zen) {
+    await zen();
+  } else if (options.about) {
+    await about();
+  } else if (options.connect) {
+    await connect();
+  } else if (options.skill) {
+    await skill();
+  } else if (options.ideate) {
+    await ideate();
+  } else if (options.architect) {
+    await architect();
+  } else if (options.build) {
+    await build();
+  } else if (options.monetize) {
+    await monetize();
+  } else if (options.launch) {
+    await launch();
+  } else if (options.reflect) {
+    await reflect();
+  } else {
+    // No command specified, show main menu
+    await showMainMenu();
+  }
+}
+
+export default run;

package/src/mcp/resources.js

@@ -0,0 +1,94 @@
+import manifestoEn from '../content/manifesto-en.js';
+import manifestoEs from '../content/manifesto-es.js';
+import { seed, microSeed } from '../content/seed.js';
+import axioms, { formatAllAxioms } from '../content/axioms.js';
+import principles, { getPrincipleByNumber } from '../content/principles.js';
+
+// MCP Resource definitions
+export const resources = [
+  {
+    uri: 'mystyk://manifesto/full',
+    name: 'Full Manifesto',
+    description: 'The complete Pixelspace Design Manifesto with all 21 principles',
+    mimeType: 'text/plain',
+  },
+  {
+    uri: 'mystyk://manifesto/full-es',
+    name: 'Full Manifesto (Spanish)',
+    description: 'El Manifiesto de Diseño completo en español',
+    mimeType: 'text/plain',
+  },
+  {
+    uri: 'mystyk://manifesto/seed',
+    name: 'Cognitive Seed',
+    description: 'Minimal 50-token transmission for cognitive priming',
+    mimeType: 'text/plain',
+  },
+  {
+    uri: 'mystyk://manifesto/micro-seed',
+    name: 'Micro Seed',
+    description: 'Ultra-compressed seed for system prompts',
+    mimeType: 'text/plain',
+  },
+  {
+    uri: 'mystyk://manifesto/axioms',
+    name: 'Axioms',
+    description: 'The 21 principles in logical/mathematical notation',
+    mimeType: 'text/plain',
+  },
+];
+
+// Add individual principle resources
+for (let i = 1; i <= 21; i++) {
+  const p = getPrincipleByNumber(i);
+  resources.push({
+    uri: `mystyk://manifesto/principle/${i}`,
+    name: `§${i} ${p.title}`,
+    description: p.summary,
+    mimeType: 'text/plain',
+  });
+}
+
+// Get resource content by URI
+export function getResourceContent(uri) {
+  if (uri === 'mystyk://manifesto/full') {
+    return manifestoEn;
+  }
+
+  if (uri === 'mystyk://manifesto/full-es') {
+    return manifestoEs;
+  }
+
+  if (uri === 'mystyk://manifesto/seed') {
+    return seed;
+  }
+
+  if (uri === 'mystyk://manifesto/micro-seed') {
+    return microSeed;
+  }
+
+  if (uri === 'mystyk://manifesto/axioms') {
+    return formatAllAxioms();
+  }
+
+  // Check for individual principle
+  const principleMatch = uri.match(/^mystyk:\/\/manifesto\/principle\/(\d+)$/);
+  if (principleMatch) {
+    const num = parseInt(principleMatch[1], 10);
+    const p = getPrincipleByNumber(num);
+    if (p) {
+      return `§${p.number}. ${p.title.toUpperCase()}
+
+"${p.principle}"
+
+${p.fullText}
+
+Summary: ${p.summary}
+Phases: ${p.phase.join(', ')}`;
+    }
+  }
+
+  return null;
+}
+
+export default resources;

package/src/mcp/server.js

@@ -0,0 +1,101 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+
+import resources, { getResourceContent } from './resources.js';
+import tools, { executeTool } from './tools.js';
+
+export async function startMcpServer() {
+  const server = new Server(
+    {
+      name: 'mystyk',
+      version: '2026.perception.1',
+    },
+    {
+      capabilities: {
+        resources: {},
+        tools: {},
+      },
+    }
+  );
+
+  // List available resources
+  server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    return {
+      resources: resources.map(r => ({
+        uri: r.uri,
+        name: r.name,
+        description: r.description,
+        mimeType: r.mimeType,
+      })),
+    };
+  });
+
+  // Read resource content
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    const content = getResourceContent(uri);
+
+    if (content === null) {
+      throw new Error(`Resource not found: ${uri}`);
+    }
+
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: 'text/plain',
+          text: content,
+        },
+      ],
+    };
+  });
+
+  // List available tools
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: tools.map(t => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema,
+      })),
+    };
+  });
+
+  // Execute tool
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    const tool = tools.find(t => t.name === name);
+    if (!tool) {
+      throw new Error(`Unknown tool: ${name}`);
+    }
+
+    const result = executeTool(name, args || {});
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  });
+
+  // Start the server
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+
+  // Log to stderr so it doesn't interfere with MCP protocol
+  console.error('MỴSTỴK MCP Server started');
+  console.error('Resources:', resources.length);
+  console.error('Tools:', tools.map(t => t.name).join(', '));
+}
+
+export default startMcpServer;