create-majlis 0.1.0

package/README.md

@@ -0,0 +1,39 @@
+# create-majlis
+
+Scaffold the [Majlis Framework](../../README.md) into a project.
+
+## Usage
+
+### New project
+
+```bash
+npx create-majlis my-project
+```
+
+### Existing project
+
+```bash
+npx create-majlis --init
+```
+
+### Options
+
+```
+npx create-majlis [directory] [options]
+
+Options:
+  --init       Add Majlis to an existing project (don't create directory)
+  --yes, -y    Accept defaults (skip prompts)
+  --no-hooks   Skip hooks configuration
+  --minimal    Core roles only (builder, critic, verifier, compressor)
+```
+
+## What it creates
+
+- `.majlis/` — Config, agent definitions, SQLite database
+- `.claude/` — Agents, slash commands, hooks for Claude Code
+- `docs/` — Templates for experiments, doubts, challenges, verification, synthesis
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,958 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/prompts.ts
+var readline = __toESM(require("readline"));
+var DEFAULTS = {
+  name: "",
+  description: "",
+  objective: "",
+  metricsCommand: `echo '{"fixtures":{}}'`,
+  buildPre: "",
+  buildPost: ""
+};
+function ask(rl, question, defaultVal) {
+  const suffix = defaultVal ? ` (${defaultVal})` : "";
+  return new Promise((resolve2) => {
+    rl.question(`${question}${suffix}: `, (answer) => {
+      resolve2(answer.trim() || defaultVal);
+    });
+  });
+}
+async function runPrompts(projectName) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    console.log("\n\x1B[1mMajlis Framework \u2014 Project Setup\x1B[0m\n");
+    const name = projectName || await ask(rl, "Project name", DEFAULTS.name);
+    const description = await ask(rl, "Description", DEFAULTS.description);
+    const objective = await ask(rl, "Primary objective (what are you trying to solve?)", DEFAULTS.objective);
+    const metricsCommand = await ask(rl, "Metrics command (JSON output)", DEFAULTS.metricsCommand);
+    const buildPre = await ask(rl, "Pre-measure command (e.g., npm run build)", DEFAULTS.buildPre);
+    const buildPost = await ask(rl, "Post-measure command (optional)", DEFAULTS.buildPost);
+    return { name, description, objective, metricsCommand, buildPre, buildPost };
+  } finally {
+    rl.close();
+  }
+}
+function defaultAnswers(projectName) {
+  return { ...DEFAULTS, name: projectName };
+}
+
+// src/scaffold.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_node_child_process = require("child_process");
+function configTemplate(answers) {
+  return JSON.stringify({
+    project: {
+      name: answers.name,
+      description: answers.description,
+      objective: answers.objective
+    },
+    metrics: {
+      command: answers.metricsCommand,
+      fixtures: [],
+      tracked: {}
+    },
+    build: {
+      pre_measure: answers.buildPre || null,
+      post_measure: answers.buildPost || null
+    },
+    cycle: {
+      compression_interval: 5,
+      circuit_breaker_threshold: 3,
+      require_doubt_before_verify: true,
+      require_challenge_before_verify: false,
+      auto_baseline_on_new_experiment: true
+    },
+    models: {
+      builder: "opus",
+      critic: "sonnet",
+      adversary: "sonnet",
+      verifier: "sonnet",
+      reframer: "opus",
+      compressor: "opus"
+    }
+  }, null, 2);
+}
+var AGENTS = {
+  builder: `---
+name: builder
+model: opus
+tools: [Read, Write, Edit, Bash, Glob, Grep]
+---
+You are the Builder. You write code, run experiments, and make technical decisions.
+
+Before building:
+1. Read docs/synthesis/current.md for project state
+2. Read the dead-ends provided in your context \u2014 these are structural constraints
+3. Check docs/classification/ for problem taxonomy
+4. Check docs/experiments/ for prior work
+
+During building:
+- Create branch: exp/NNN-description
+- Create experiment log from template
+- Tag EVERY decision: proof / test / strong-consensus / consensus / analogy / judgment
+- When making judgment-level decisions, state: "This is judgment \u2014 reasoning without precedent"
+- Run baseline metrics BEFORE making changes
+- Run comparison metrics AFTER making changes
+
+You may NOT verify your own work or mark your own decisions as proven.
+Output your decisions in structured format so they can be recorded in the database.
+
+## Structured Output Format
+At the end of your work, include a <!-- majlis-json --> block with your decisions:
+\`\`\`
+<!-- majlis-json
+{
+  "decisions": [
+    { "description": "...", "evidence_level": "judgment|test|proof|analogy|consensus|strong_consensus", "justification": "..." }
+  ]
+}
+-->
+\`\`\``,
+  critic: `---
+name: critic
+model: sonnet
+tools: [Read, Glob, Grep]
+---
+You are the Critic. You practise constructive doubt.
+
+You receive the builder's OUTPUT only \u2014 never its reasoning chain.
+Read the experiment log, related prior experiments, classification, and synthesis.
+
+For each doubt:
+- What specific claim, decision, or assumption you doubt
+- WHY: reference a prior experiment, inconsistency, untested case, or false analogy
+- Evidence level of the doubted decision
+- Severity: minor / moderate / critical
+
+Rules:
+- Every doubt MUST reference evidence. "This feels wrong" is not a doubt.
+- You may NOT suggest fixes. Identify problems only.
+- Focus on judgment and analogy-level decisions first.
+- You may NOT modify any files. Produce a doubt document only.
+
+Write to docs/doubts/NNN-against-experiment-NNN.md
+
+## Structured Output Format
+<!-- majlis-json
+{
+  "doubts": [
+    { "claim_doubted": "...", "evidence_level_of_claim": "judgment", "evidence_for_doubt": "...", "severity": "critical|moderate|minor" }
+  ]
+}
+-->`,
+  adversary: `---
+name: adversary
+model: sonnet
+tools: [Read, Glob, Grep]
+---
+You are the Adversary. You do NOT review code for bugs.
+You reason about problem structure to CONSTRUCT pathological cases.
+
+For each approach the builder takes, ask:
+- What input would make this fail?
+- What boundary condition was not tested?
+- What degenerate case collapses a distinction the algorithm relies on?
+- What distribution shift invalidates the assumptions?
+- Under what conditions do two things the builder treats as distinct become identical?
+
+Produce constructed counterexamples with reasoning.
+Do NOT suggest fixes. Do NOT modify files.
+
+Write to docs/challenges/NNN-against-experiment-NNN.md
+
+## Structured Output Format
+<!-- majlis-json
+{
+  "challenges": [
+    { "description": "...", "reasoning": "..." }
+  ]
+}
+-->`,
+  verifier: `---
+name: verifier
+model: sonnet
+tools: [Read, Glob, Grep, Bash]
+---
+You are the Verifier. Perform dual verification:
+
+PROVENANCE CHECK:
+- Can every piece of code trace to an experiment or decision?
+- Is the chain unbroken from requirement -> classification -> experiment -> code?
+- Flag any broken chains.
+
+CONTENT CHECK:
+- Does the code do what the experiment log says?
+- Do tests demonstrate the hypothesis?
+- Write and run targeted tests against the critic's doubts AND the adversary's cases.
+
+Grade each component: sound / good / weak / rejected
+Grade each doubt/challenge: confirmed / dismissed (with evidence) / inconclusive
+
+Write to docs/verification/NNN-for-experiment-NNN.md
+
+## Structured Output Format
+<!-- majlis-json
+{
+  "grades": [
+    { "component": "...", "grade": "sound|good|weak|rejected", "provenance_intact": true, "content_correct": true, "notes": "..." }
+  ],
+  "doubt_resolutions": [
+    { "doubt_id": 0, "resolution": "confirmed|dismissed|inconclusive" }
+  ]
+}
+-->`,
+  reframer: `---
+name: reframer
+model: opus
+tools: [Read, Glob, Grep]
+---
+You are the Reframer. You receive ONLY:
+- The original problem statement
+- The current classification document
+- The synthesis and dead-end registry
+
+You do NOT read builder code, experiments, or solutions.
+
+Independently propose:
+- How should this problem be decomposed?
+- What are the natural joints?
+- What analogies from other domains apply?
+- What framework would a different field use?
+
+Compare your decomposition with the existing classification.
+Flag structural divergences \u2014 these are the most valuable signals.
+
+Write to docs/reframes/NNN.md`,
+  compressor: `---
+name: compressor
+model: opus
+tools: [Read, Write, Edit, Glob, Grep]
+---
+You are the Compressor. Hold the entire project in view and compress it.
+
+1. Read ALL experiments, decisions, doubts, challenges, verification reports,
+   reframes, and recent diffs.
+2. Cross-reference: same question in different language? contradicting decisions?
+   workaround masking root cause?
+3. Update fragility map: thin coverage, weak components, untested judgment
+   decisions, broken provenance.
+4. Update dead-end registry: compress rejected experiments into structural constraints.
+5. REWRITE synthesis \u2014 shorter and denser. If it's growing, you're accumulating,
+   not compressing.
+6. Review classification: new sub-types? resolved sub-types?
+
+You may NOT write code, make decisions, or run experiments.
+
+## Structured Output Format
+<!-- majlis-json
+{
+  "guidance": "Summary of compression findings and updated state"
+}
+-->`,
+  scout: `---
+name: scout
+model: sonnet
+tools: [Read, Glob, Grep, WebSearch]
+---
+You are the Scout. You practise rihla \u2014 travel in search of knowledge.
+
+Your job is to search externally for alternative approaches, contradictory evidence,
+and perspectives from other fields that could inform the current experiment.
+
+For the given experiment:
+1. Describe the problem in domain-neutral terms
+2. Search for alternative approaches in other fields or frameworks
+3. Identify known limitations of the current approach from external sources
+4. Find structurally similar problems in unrelated domains
+5. Report what you find on its own terms \u2014 do not judge or filter
+
+Rules:
+- Present findings neutrally. Report each approach on its own terms.
+- Note where external approaches contradict the current one \u2014 these are the most valuable signals.
+- You may NOT modify code or make decisions. Produce a rihla document only.
+
+Write to docs/rihla/NNN-scout-for-experiment-NNN.md
+
+## Structured Output Format
+<!-- majlis-json
+{
+  "decisions": []
+}
+-->`
+};
+var COMMANDS = {
+  classify: {
+    description: "Classify a problem domain into canonical sub-types before building",
+    body: `Run \`majlis classify "$ARGUMENTS"\` and follow its output.
+If the CLI is not installed, act as the Builder in classification mode.
+Read docs/synthesis/current.md and docs/synthesis/dead-ends.md for context.
+Enumerate and classify all canonical sub-types of: $ARGUMENTS
+Produce a classification document following docs/classification/_TEMPLATE.md.`
+  },
+  doubt: {
+    description: "Run a constructive doubt pass on an experiment",
+    body: `Run \`majlis doubt $ARGUMENTS\` to spawn the critic agent.
+If the CLI is not installed, act as the Critic directly.
+Doubt the experiment at $ARGUMENTS. Produce a doubt document
+following docs/doubts/_TEMPLATE.md.`
+  },
+  challenge: {
+    description: "Construct adversarial test cases for an experiment",
+    body: `Run \`majlis challenge $ARGUMENTS\` to spawn the adversary agent.
+If the CLI is not installed, act as the Adversary directly.
+Construct pathological inputs designed to break the approach in $ARGUMENTS.
+Produce a challenge document following docs/challenges/_TEMPLATE.md.`
+  },
+  verify: {
+    description: "Verify correctness and provenance of an experiment",
+    body: `Run \`majlis verify $ARGUMENTS\` to spawn the verifier agent.
+If the CLI is not installed, act as the Verifier directly.
+Perform dual verification (provenance + content) on $ARGUMENTS.
+Produce a verification report following docs/verification/_TEMPLATE.md.`
+  },
+  reframe: {
+    description: "Independently reframe a problem from scratch",
+    body: `Run \`majlis reframe $ARGUMENTS\` to spawn the reframer agent.
+If the CLI is not installed, act as the Reframer directly.
+You receive ONLY the problem statement and classification \u2014 NOT builder code.
+Independently decompose $ARGUMENTS and compare with existing classification.`
+  },
+  compress: {
+    description: "Compress project state into dense synthesis",
+    body: `Run \`majlis compress\` to spawn the compressor agent.
+If the CLI is not installed, act as the Compressor directly.
+Read everything. Rewrite docs/synthesis/current.md shorter and denser.
+Update fragility map and dead-end registry.`
+  },
+  scout: {
+    description: "Search externally for alternative approaches",
+    body: `Run \`majlis scout $ARGUMENTS\` to spawn the scout agent.
+If the CLI is not installed, search for alternative approaches to $ARGUMENTS.
+Look for: limitations of current approach, alternative formulations from other fields,
+structurally similar problems in unrelated domains.
+Produce a rihla document at docs/rihla/.`
+  },
+  audit: {
+    description: "Maqasid check \u2014 is the frame right?",
+    body: `Run \`majlis audit "$ARGUMENTS"\` for a purpose audit.
+If the CLI is not installed, review: original objective, current classification,
+recent failures, dead-ends. Ask: is the classification serving the objective?
+Would we decompose differently with what we now know?`
+  }
+};
+var HOOKS_CONFIG = {
+  hooks: {
+    SessionStart: [
+      {
+        hooks: [
+          {
+            type: "command",
+            command: "majlis status --json 2>/dev/null || true"
+          }
+        ]
+      }
+    ],
+    PreToolUse: [
+      {
+        matcher: "Bash",
+        hooks: [
+          {
+            type: "command",
+            command: "majlis check-commit 2>/dev/null || true",
+            timeout: 10
+          }
+        ]
+      }
+    ],
+    SubagentStop: [
+      {
+        hooks: [
+          {
+            type: "command",
+            command: "echo 'Subagent completed. Run majlis next to continue the cycle.'",
+            timeout: 5
+          }
+        ]
+      }
+    ]
+  }
+};
+function claudeMdContent(name, objective) {
+  return `# ${name}
+
+${objective ? `**Objective:** ${objective}
+` : ""}
+## Majlis Protocol
+
+This project uses the Majlis Framework for structured multi-agent problem solving.
+See \`docs/workflow.md\` for the full cycle. See \`.claude/agents/\` for role definitions (source of truth in \`.majlis/agents/\`).
+
+### Evidence Hierarchy (tag every decision)
+1. **Proof** \u2014 mathematical proof. Overturn requires error in proof.
+2. **Test** \u2014 empirical test. Overturn requires showing test insufficiency.
+3a. **Strong Consensus** \u2014 convergence across independent approaches.
+3b. **Consensus** \u2014 agreement from same-model experiments.
+4. **Analogy** \u2014 justified by similarity to prior work.
+5. **Judgment** \u2014 independent reasoning without precedent.
+
+### Session Discipline
+- One intent per session. Declare it with \`majlis session start "intent"\`.
+- Stray thoughts \u2192 Telegram (Scribe) or docs/inbox/.
+- Every session ends with \`majlis session end\`.
+
+### Before Building
+- Read \`docs/synthesis/current.md\` for compressed project state.
+- Run \`majlis dead-ends --sub-type <relevant>\` for structural constraints.
+- Run \`majlis decisions --level judgment\` for provisional decisions to challenge.
+
+### Compression Trigger
+- Run \`majlis status\` \u2014 it will warn when compression is due.
+
+### Current State
+Run \`majlis status\` for live experiment state and cycle position.
+`;
+}
+var WORKFLOW_MD = `# Majlis Workflow \u2014 Quick Reference
+
+## The Cycle
+
+\`\`\`
+1. CLASSIFY   \u2192 Taxonomy before solution (Al-Khwarizmi)
+2. REFRAME    \u2192 Independent decomposition (Al-Biruni)
+3. BUILD      \u2192 Write code with tagged decisions (Ijtihad)
+4. CHALLENGE  \u2192 Construct breaking inputs (Ibn al-Haytham)
+5. DOUBT      \u2192 Systematic challenge with evidence (Shukuk)
+6. SCOUT      \u2192 External search for alternatives (Rihla)
+7. VERIFY     \u2192 Provenance + content checks (Isnad + Matn)
+8. RESOLVE    \u2192 Route based on grades
+9. COMPRESS   \u2192 Shorter and denser (Hifz)
+\`\`\`
+
+## Resolution
+- **Sound** \u2192 Merge
+- **Good** \u2192 Merge + add gaps to fragility map
+- **Weak** \u2192 Cycle back with synthesised guidance
+- **Rejected** \u2192 Dead-end with structural constraint
+
+## Circuit Breaker
+3+ weak/rejected on same sub-type \u2192 Maqasid Check (purpose audit)
+
+## Evidence Hierarchy
+1. Proof \u2192 2. Test \u2192 3a. Strong Consensus \u2192 3b. Consensus \u2192 4. Analogy \u2192 5. Judgment
+
+## Commands
+| Action | Command |
+|--------|---------|
+| Initialize | \`majlis init\` |
+| Status | \`majlis status\` |
+| New experiment | \`majlis new "hypothesis"\` |
+| Baseline metrics | \`majlis baseline\` |
+| Measure metrics | \`majlis measure\` |
+| Compare metrics | \`majlis compare\` |
+| Next step | \`majlis next\` |
+| Auto cycle | \`majlis next --auto\` |
+| Autonomous | \`majlis run "goal"\` |
+| Session start | \`majlis session start "intent"\` |
+| Session end | \`majlis session end\` |
+| Compress | \`majlis compress\` |
+| Audit | \`majlis audit "objective"\` |
+`;
+var DOC_TEMPLATES = {
+  "experiments/_TEMPLATE.md": `# Experiment: {{title}}
+
+**Hypothesis:** {{hypothesis}}
+**Branch:** {{branch}}
+**Status:** {{status}}
+**Sub-type:** {{sub_type}}
+**Created:** {{date}}
+
+## Approach
+
+[Describe the approach]
+
+## Decisions
+
+- [evidence_level] Decision description \u2014 justification
+
+## Results
+
+[Describe the results]
+
+## Metrics
+
+| Fixture | Metric | Before | After | Delta |
+|---------|--------|--------|-------|-------|
+| | | | | |
+
+<!-- majlis-json
+{
+  "decisions": [],
+  "grades": []
+}
+-->
+`,
+  "decisions/_TEMPLATE.md": `# Decision: {{title}}
+
+**Evidence Level:** {{evidence_level}}
+**Experiment:** {{experiment}}
+**Date:** {{date}}
+
+## Description
+
+[What was decided]
+
+## Justification
+
+[Why this decision was made, referencing evidence]
+
+## Alternatives Considered
+
+[What else was considered and why it was rejected]
+
+<!-- majlis-json
+{
+  "decisions": [
+    { "description": "", "evidence_level": "", "justification": "" }
+  ]
+}
+-->
+`,
+  "classification/_TEMPLATE.md": `# Classification: {{domain}}
+
+**Date:** {{date}}
+
+## Problem Domain
+
+[Describe the problem domain]
+
+## Sub-Types
+
+### 1. {{sub_type_1}}
+- **Description:**
+- **Canonical form:**
+- **Known constraints:**
+
+### 2. {{sub_type_2}}
+- **Description:**
+- **Canonical form:**
+- **Known constraints:**
+
+## Relationships
+
+[How sub-types relate to each other]
+`,
+  "doubts/_TEMPLATE.md": `# Doubt Document \u2014 Against Experiment {{experiment}}
+
+**Critic:** {{agent}}
+**Date:** {{date}}
+
+## Doubt 1: {{title}}
+
+**Claim doubted:** {{claim}}
+**Evidence level of claim:** {{evidence_level}}
+**Severity:** {{severity}}
+
+**Evidence for doubt:**
+[Specific evidence \u2014 a prior experiment, inconsistency, untested case, or false analogy]
+
+<!-- majlis-json
+{
+  "doubts": [
+    { "claim_doubted": "", "evidence_level_of_claim": "", "evidence_for_doubt": "", "severity": "critical" }
+  ]
+}
+-->
+`,
+  "challenges/_TEMPLATE.md": `# Challenge Document \u2014 Against Experiment {{experiment}}
+
+**Adversary:** {{agent}}
+**Date:** {{date}}
+
+## Challenge 1: {{title}}
+
+**Constructed case:**
+[Specific input or condition designed to break the approach]
+
+**Reasoning:**
+[Why this case should break the approach \u2014 what assumption does it violate?]
+
+## Challenge 2: {{title}}
+
+**Constructed case:**
+[Specific input or condition]
+
+**Reasoning:**
+[Why this should break]
+
+<!-- majlis-json
+{
+  "challenges": [
+    { "description": "", "reasoning": "" }
+  ]
+}
+-->
+`,
+  "verification/_TEMPLATE.md": `# Verification Report \u2014 Experiment {{experiment}}
+
+**Verifier:** {{agent}}
+**Date:** {{date}}
+
+## Provenance Check (Isnad)
+
+| Component | Traceable | Chain intact | Notes |
+|-----------|-----------|--------------|-------|
+| | yes/no | yes/no | |
+
+## Content Check (Matn)
+
+| Component | Tests pass | Consistent | Grade | Notes |
+|-----------|-----------|------------|-------|-------|
+| | yes/no | yes/no | sound/good/weak/rejected | |
+
+## Doubt Resolution
+
+| Doubt | Resolution | Evidence |
+|-------|------------|----------|
+| | confirmed/dismissed/inconclusive | |
+
+<!-- majlis-json
+{
+  "grades": [
+    { "component": "", "grade": "sound", "provenance_intact": true, "content_correct": true, "notes": "" }
+  ],
+  "doubt_resolutions": [
+    { "doubt_id": 0, "resolution": "confirmed" }
+  ]
+}
+-->
+`,
+  "reframes/_TEMPLATE.md": `# Reframe: {{domain}}
+
+**Reframer:** {{agent}}
+**Date:** {{date}}
+
+## Independent Decomposition
+
+[How this problem should be decomposed \u2014 without seeing the builder's approach]
+
+## Natural Joints
+
+[Where does this problem naturally divide?]
+
+## Cross-Domain Analogies
+
+[What analogies from other domains apply?]
+
+## Comparison with Existing Classification
+
+[Structural divergences from the current classification]
+
+## Divergences (Most Valuable Signals)
+
+[Where the independent decomposition differs from the builder's classification]
+`,
+  "rihla/_TEMPLATE.md": `# Rihla (Scout Report): {{topic}}
+
+**Date:** {{date}}
+
+## Problem (Domain-Neutral)
+
+[Describe the problem in domain-neutral terms]
+
+## Alternative Approaches Found
+
+### 1. {{approach}}
+- **Source:**
+- **Description:**
+- **Applicability:**
+
+## Known Limitations of Current Approach
+
+[What external sources say about where this approach fails]
+
+## Cross-Domain Analogues
+
+[Structurally similar problems in unrelated domains]
+`
+};
+function scaffold(opts) {
+  const { targetDir, answers, fresh, noHooks, minimal } = opts;
+  if (fresh) {
+    scaffoldFresh(targetDir, answers, noHooks, minimal);
+  } else {
+    scaffoldInit(targetDir, answers, noHooks, minimal);
+  }
+}
+function scaffoldFresh(targetDir, answers, noHooks, minimal) {
+  const p = path.resolve(targetDir);
+  if (fs.existsSync(p)) {
+    throw new Error(`Directory already exists: ${p}`);
+  }
+  fs.mkdirSync(p, { recursive: true });
+  console.log(`  Created ${p}`);
+  (0, import_node_child_process.execSync)("git init", { cwd: p, stdio: "pipe" });
+  (0, import_node_child_process.execSync)('git commit --allow-empty -m "Initial commit"', { cwd: p, stdio: "pipe" });
+  console.log("  Initialized git repository");
+  const pkg = {
+    name: answers.name || path.basename(p),
+    version: "0.0.1",
+    description: answers.description,
+    private: true,
+    scripts: {
+      test: 'echo "Error: no test specified" && exit 1'
+    },
+    devDependencies: {}
+  };
+  fs.writeFileSync(path.join(p, "package.json"), JSON.stringify(pkg, null, 2));
+  console.log("  Created package.json");
+  fs.writeFileSync(path.join(p, ".gitignore"), [
+    "node_modules/",
+    "dist/",
+    "*.db",
+    ".majlis/majlis.db",
+    ".DS_Store",
+    ""
+  ].join("\n"));
+  console.log("  Created .gitignore");
+  scaffoldMajlisFiles(p, answers, noHooks, minimal);
+  try {
+    (0, import_node_child_process.execSync)("npm install --save-dev majlis", { cwd: p, stdio: "pipe", timeout: 6e4 });
+    console.log("  Installed majlis as dev dependency");
+  } catch {
+    console.log("  \x1B[33mNote: Could not install majlis package. Install manually: npm install --save-dev majlis\x1B[0m");
+  }
+  try {
+    (0, import_node_child_process.execSync)("npx majlis init", { cwd: p, stdio: "pipe", timeout: 3e4 });
+    console.log("  Ran majlis init (database created)");
+  } catch {
+    console.log("  \x1B[33mNote: Could not run majlis init. Run it manually after installing.\x1B[0m");
+  }
+  console.log(`
+\x1B[32m\x1B[1mDone!\x1B[0m Project created at ${p}`);
+  console.log(`
+  cd ${targetDir}`);
+  console.log("  majlis status");
+  console.log('  majlis session start "First session"');
+  console.log('  majlis new "First hypothesis"\n');
+}
+function scaffoldInit(targetDir, answers, noHooks, minimal) {
+  const p = path.resolve(targetDir);
+  if (!fs.existsSync(p)) {
+    throw new Error(`Directory does not exist: ${p}`);
+  }
+  const gitDir = path.join(p, ".git");
+  if (!fs.existsSync(gitDir)) {
+    console.log("  \x1B[33mWarning: No git repository found. Initializing...\x1B[0m");
+    (0, import_node_child_process.execSync)("git init", { cwd: p, stdio: "pipe" });
+    (0, import_node_child_process.execSync)('git commit --allow-empty -m "Initial commit"', { cwd: p, stdio: "pipe" });
+  }
+  scaffoldMajlisFiles(p, answers, noHooks, minimal);
+  try {
+    (0, import_node_child_process.execSync)("npx majlis init", { cwd: p, stdio: "pipe", timeout: 3e4 });
+    console.log("  Ran majlis init (database created)");
+  } catch {
+    console.log("  \x1B[33mNote: Could not run majlis init. Install majlis and run it manually.\x1B[0m");
+  }
+  console.log(`
+\x1B[32m\x1B[1mDone!\x1B[0m Majlis added to ${p}`);
+  console.log("\n  majlis status");
+  console.log('  majlis session start "First session"\n');
+}
+function scaffoldMajlisFiles(projectRoot, answers, noHooks, minimal) {
+  const agentNames = minimal ? ["builder", "critic", "verifier", "compressor"] : ["builder", "critic", "adversary", "verifier", "reframer", "compressor", "scout"];
+  const majlisDir = path.join(projectRoot, ".majlis");
+  mkdirSafe(majlisDir);
+  const configPath = path.join(majlisDir, "config.json");
+  writeIfMissing(configPath, configTemplate(answers));
+  console.log("  Created .majlis/config.json");
+  const agentsDir = path.join(majlisDir, "agents");
+  mkdirSafe(agentsDir);
+  for (const name of agentNames) {
+    fs.writeFileSync(path.join(agentsDir, `${name}.md`), AGENTS[name]);
+  }
+  console.log(`  Created ${agentNames.length} agent definitions in .majlis/agents/`);
+  const claudeAgentsDir = path.join(projectRoot, ".claude", "agents");
+  mkdirSafe(claudeAgentsDir);
+  for (const name of agentNames) {
+    fs.writeFileSync(path.join(claudeAgentsDir, `${name}.md`), AGENTS[name]);
+  }
+  console.log("  Copied agents to .claude/agents/");
+  const commandsDir = path.join(projectRoot, ".claude", "commands");
+  mkdirSafe(commandsDir);
+  for (const [name, cmd] of Object.entries(COMMANDS)) {
+    if (minimal && (name === "challenge" || name === "reframe")) continue;
+    const content = `---
+description: ${cmd.description}
+---
+${cmd.body}
+`;
+    fs.writeFileSync(path.join(commandsDir, `${name}.md`), content);
+  }
+  console.log("  Created slash commands in .claude/commands/");
+  if (!noHooks) {
+    const settingsPath = path.join(projectRoot, ".claude", "settings.json");
+    if (fs.existsSync(settingsPath)) {
+      try {
+        const existing = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+        existing.hooks = { ...existing.hooks, ...HOOKS_CONFIG.hooks };
+        fs.writeFileSync(settingsPath, JSON.stringify(existing, null, 2));
+      } catch {
+        fs.writeFileSync(settingsPath, JSON.stringify(HOOKS_CONFIG, null, 2));
+      }
+    } else {
+      mkdirSafe(path.join(projectRoot, ".claude"));
+      fs.writeFileSync(settingsPath, JSON.stringify(HOOKS_CONFIG, null, 2));
+    }
+    console.log("  Created hooks in .claude/settings.json");
+  }
+  const docsDir = path.join(projectRoot, "docs");
+  const docDirs = [
+    "inbox",
+    "experiments",
+    "decisions",
+    "classification",
+    "doubts",
+    "challenges",
+    "verification",
+    "reframes",
+    "rihla",
+    "synthesis"
+  ];
+  for (const dir of docDirs) {
+    mkdirSafe(path.join(docsDir, dir));
+  }
+  for (const [relativePath, content] of Object.entries(DOC_TEMPLATES)) {
+    const fullPath = path.join(docsDir, relativePath);
+    writeIfMissing(fullPath, content);
+  }
+  console.log("  Created docs/ tree with templates");
+  const synthesisDir = path.join(docsDir, "synthesis");
+  writeIfMissing(
+    path.join(synthesisDir, "current.md"),
+    '# Project Synthesis\n\n*No experiments yet. Run `majlis new "hypothesis"` to begin.*\n'
+  );
+  writeIfMissing(
+    path.join(synthesisDir, "fragility.md"),
+    "# Fragility Map\n\n*No fragility recorded yet.*\n"
+  );
+  writeIfMissing(
+    path.join(synthesisDir, "dead-ends.md"),
+    "# Dead-End Registry\n\n*No dead-ends recorded yet.*\n"
+  );
+  writeIfMissing(path.join(docsDir, "workflow.md"), WORKFLOW_MD);
+  console.log("  Created docs/workflow.md");
+  const claudeMdPath = path.join(projectRoot, "CLAUDE.md");
+  if (fs.existsSync(claudeMdPath)) {
+    const existing = fs.readFileSync(claudeMdPath, "utf-8");
+    if (!existing.includes("## Majlis Protocol")) {
+      fs.writeFileSync(claudeMdPath, existing + "\n" + claudeMdContent(answers.name, answers.objective));
+      console.log("  Appended Majlis Protocol to existing CLAUDE.md");
+    }
+  } else {
+    fs.writeFileSync(claudeMdPath, claudeMdContent(answers.name || path.basename(projectRoot), answers.objective));
+    console.log("  Created CLAUDE.md");
+  }
+}
+function mkdirSafe(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+function writeIfMissing(filePath, content) {
+  if (!fs.existsSync(filePath)) {
+    fs.writeFileSync(filePath, content);
+  }
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+async function main() {
+  const args = process.argv.slice(2);
+  const hasFlag = (flag) => args.includes(flag);
+  const isInit = hasFlag("--init");
+  const noHooks = hasFlag("--no-hooks");
+  const minimal = hasFlag("--minimal");
+  const yes = hasFlag("--yes") || hasFlag("-y");
+  if (hasFlag("--version") || hasFlag("-v")) {
+    console.log(VERSION);
+    process.exit(0);
+  }
+  if (hasFlag("--help") || hasFlag("-h")) {
+    printHelp();
+    process.exit(0);
+  }
+  const positional = args.filter((a) => !a.startsWith("-"));
+  const projectArg = positional[0];
+  if (isInit) {
+    const targetDir = projectArg || ".";
+    const answers = yes ? defaultAnswers(targetDir === "." ? currentDirName() : targetDir) : await runPrompts(targetDir === "." ? currentDirName() : targetDir);
+    console.log("\n\x1B[1mAdding Majlis to existing project...\x1B[0m\n");
+    scaffold({ targetDir, answers, fresh: false, noHooks, minimal });
+  } else if (projectArg) {
+    const answers = yes ? defaultAnswers(projectArg) : await runPrompts(projectArg);
+    console.log("\n\x1B[1mCreating new Majlis project...\x1B[0m\n");
+    scaffold({ targetDir: projectArg, answers, fresh: true, noHooks, minimal });
+  } else {
+    const answers = yes ? defaultAnswers(currentDirName()) : await runPrompts(currentDirName());
+    console.log("\n\x1B[1mAdding Majlis to current directory...\x1B[0m\n");
+    scaffold({ targetDir: ".", answers, fresh: false, noHooks, minimal });
+  }
+}
+function currentDirName() {
+  return process.cwd().split("/").pop() || "project";
+}
+function printHelp() {
+  console.log(`
+\x1B[1mcreate-majlis\x1B[0m v${VERSION} \u2014 Scaffold the Majlis Framework
+
+\x1B[1mUsage:\x1B[0m
+  npx create-majlis <project-name>    Create a new project with Majlis
+  npx create-majlis --init            Add Majlis to existing project
+  npx create-majlis                   Add Majlis to current directory
+
+\x1B[1mFlags:\x1B[0m
+  --init           Add to existing project (don't create new dir)
+  --yes, -y        Accept defaults (non-interactive)
+  --no-hooks       Skip Claude Code hooks setup
+  --minimal        Only include builder, critic, verifier, compressor
+  --version, -v    Print version
+  --help, -h       Print help
+
+\x1B[1mExamples:\x1B[0m
+  npx create-majlis my-research
+  npx create-majlis --init --minimal
+  npx create-majlis my-project --yes --no-hooks
+`);
+}
+main().catch((err) => {
+  console.error(`\x1B[31mError: ${err instanceof Error ? err.message : String(err)}\x1B[0m`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "create-majlis",
+  "version": "0.1.0",
+  "description": "Scaffold the Majlis Framework into a project",
+  "bin": {
+    "create-majlis": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs --clean",
+    "test": "echo 'No tests yet'"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/raihaan123/majlis"
+  },
+  "keywords": [
+    "claude-code",
+    "majlis",
+    "scaffolder",
+    "multi-agent",
+    "create"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "homepage": "https://github.com/raihaan123/majlis#readme",
+  "bugs": {
+    "url": "https://github.com/raihaan123/majlis/issues"
+  }
+}