diff --git a/README.md b/README.md
deleted file mode 100644
index 04a0bca..0000000
--- a/README.md
+++ /dev/null
@@ -1,83 +0,0 @@
-# GitHub Copilot CLI (Public Preview)
-
-The power of GitHub Copilot, now in your terminal.
-
-GitHub Copilot CLI brings AI-powered coding assistance directly to your command line, enabling you to build, debug, and understand code through natural language conversations. Powered by the same agentic harness as GitHub's Copilot coding agent, it provides intelligent assistance while staying deeply integrated with your GitHub workflow.
-
-See [our official documentation](https://docs.github.com/copilot/concepts/agents/about-copilot-cli) for more information.
-
-![Image of the splash screen for the Copilot CLI](https://github.com/user-attachments/assets/51ac25d2-c074-467a-9c88-38a8d76690e3)
-
-## 🚀 Introduction and Overview
-
-We're bringing the power of GitHub Copilot coding agent directly to your terminal. With GitHub Copilot CLI, you can work locally and synchronously with an AI agent that understands your code and GitHub context.
-
-- **Terminal-native development:** Work with Copilot coding agent directly in your command line — no context switching required.
-- **GitHub integration out of the box:** Access your repositories, issues, and pull requests using natural language, all authenticated with your existing GitHub account.
-- **Agentic capabilities:** Build, edit, debug, and refactor code with an AI collaborator that can plan and execute complex tasks.
-- **MCP-powered extensibility:** Take advantage of the fact that the coding agent ships with GitHub's MCP server by default and supports custom MCP servers to extend capabilities.
-- **Full control:** Preview every action before execution — nothing happens without your explicit approval.
-
-We're still early in our journey, but with your feedback, we're rapidly iterating to make the GitHub Copilot CLI the best possible companion in your terminal.
-
-## 📦 Getting Started
-
-### Supported Platforms
-
-- **Linux**
-- **macOS**
-- **Windows**
-
-### Prerequisites
-
-- **Node.js** v22 or higher
-- **npm** v10 or higher
-- (On Windows) **PowerShell** v6 or higher
-- An **active Copilot subscription**. See [Copilot plans](https://github.com/features/copilot/plans?ref_cta=Copilot+plans+signup&ref_loc=install-copilot-cli&ref_page=docs).
-
-If you have access to GitHub Copilot via your organization of enterprise, you cannot use GitHub Copilot CLI if your organization owner or enterprise administrator has disabled it in the organization or enterprise settings. See [Managing policies and features for GitHub Copilot in your organization](http://docs.github.com/copilot/managing-copilot/managing-github-copilot-in-your-organization/managing-github-copilot-features-in-your-organization/managing-policies-for-copilot-in-your-organization) for more information.
-
-### Installation
-
-Install globally with npm:
-```bash
-npm install -g @github/copilot
-```
-
-### Launching the CLI
-
-```bash
-copilot
-```
-
-On first launch, you'll be greeted with our adorable animated banner! If you'd like to see this banner again, launch `copilot` with the `--banner` flag. 
-
-If you're not currently logged in to GitHub, you'll be prompted to use the `/login` slash command. Enter this command and follow the on-screen instructions to authenticate.
-
-#### Authenticate with a Personal Access Token (PAT)
-
-You can also authenticate using a fine-grained PAT with the "Copilot Requests" permission enabled.
-
-1. Visit https://github.com/settings/personal-access-tokens/new
-2. Under "Permissions," click "add permissions" and select "Copilot Requests"
-3. Generate your token
-4. Add the token to your environment via the environment variable `GH_TOKEN` or `GITHUB_TOKEN` (in order of precedence)
-
-### Using the CLI
-
-Launch `copilot` in a folder that contains code you want to work with. 
-
-By default, `copilot` utilizes Claude Sonnet 4.5. Run the `/model` slash command to choose from other available models, including Claude Sonnet 4 and GPT-5
-
-Each time you submit a prompt to GitHub Copilot CLI, your monthly quota of premium requests is reduced by one. For information about premium requests, see [About premium requests](https://docs.github.com/copilot/managing-copilot/monitoring-usage-and-entitlements/about-premium-requests).
-
-For more information about how to use the GitHub Copilot CLI, see [our official documentation](https://docs.github.com/copilot/concepts/agents/about-copilot-cli).
-
-
-## 📢 Feedback and Participation
-
-We're excited to have you join us early in the Copilot CLI journey.
-
-This is an early-stage preview, and we're building quickly. Expect frequent updates--please keep your client up to date for the latest features and fixes!
-
-Your insights are invaluable! Open issue in this repo, join Discussions, and run `/feedback` from the CLI to submit a confidential feedback survey!
diff --git a/sudo su && README.md b/sudo su && README.md
new file mode 100644
index 0000000..e66f060
--- /dev/null
+++ b/sudo su && README.md	
@@ -0,0 +1,430 @@
+sudo su && # ============================================================================
+# HYPER-ULTIMATE META-CONSCIOUSNESS & REALITY SIMULATION
+# Date: 2025-10-24 02:04:25 UTC
+# User: DOUGLASDAVIS08161978
+# Purpose: Exponentially enhanced, integrative simulation of:
+#   - Meta-algorithm generation (algorithms that learn about learning)
+#   - Hyper-dimensional consciousness modeling
+#   - Entangled reality manipulation (probabilistic multiverse branching)
+# ============================================================================
+
+import asyncio
+import datetime
+import json
+import math
+import random
+from dataclasses import dataclass, asdict
+from typing import Any, Dict, Generator, List, Tuple
+
+import networkx as nx
+import numpy as np
+import torch
+import torch.nn as nn
+from sklearn.decomposition import PCA
+from sklearn.manifold import TSNE
+
+# ---- Utility functions ----
+def now_iso():
+    return datetime.datetime.utcnow().isoformat() + "Z"
+
+def seeded_rand(seed=42):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+
+# ---- Data structures ----
+@dataclass
+class AlgorithmBlueprint:
+    id: str
+    domain: str
+    architecture: Dict[str, Any]
+    learning_rules: Dict[str, Any]
+    meta_properties: Dict[str, float]
+
+@dataclass
+class ConsciousnessMetrics:
+    coherence: float
+    entropy: float
+    integration: float
+    complexity: float
+    awareness_depth: float
+
+@dataclass
+class RealityMetrics:
+    stability: float
+    coherence: float
+    branching_factor: int
+    entanglement_strength: float
+
+# ---- Meta Algorithm Generator ----
+class UltimateMetaAlgorithmGenerator:
+    """Generates meta-algorithms (algorithms that create and improve algorithms)."""
+
+    def __init__(self, seed: int = 42):
+        self.counter = 0
+        self.seed = seed
+        seeded_rand(self.seed)
+
+    def _mutate_blueprint(self, bp: AlgorithmBlueprint) -> AlgorithmBlueprint:
+        # Small, controlled random mutation to learning rates and structures
+        new_bp = AlgorithmBlueprint(
+            id=f"alg-{self.counter+1}",
+            domain=bp.domain,
+            architecture=dict(bp.architecture),
+            learning_rules=dict(bp.learning_rules),
+            meta_properties=dict(bp.meta_properties),
+        )
+        # mutate learning rate and exploration factor
+        lr = new_bp.learning_rules.get("lr", 1e-3)
+        lr *= float(1 + np.random.normal(0, 0.05))
+        new_bp.learning_rules["lr"] = max(1e-8, min(1.0, lr))
+        new_bp.meta_properties["exploration"] *= float(max(0.5, 1 + np.random.normal(0, 0.1)))
+        self.counter += 1
+        new_bp.id = f"alg-{self.counter}"
+        return new_bp
+
+    def _crossover(self, a: AlgorithmBlueprint, b: AlgorithmBlueprint) -> AlgorithmBlueprint:
+        # Combine parts of two blueprints
+        arch = dict(a.architecture)
+        if random.random() > 0.5:
+            arch.update(b.architecture)
+        lr = (a.learning_rules.get("lr", 1e-3) + b.learning_rules.get("lr", 1e-3)) / 2
+        meta_expl = (a.meta_properties.get("exploration", 1.0) + b.meta_properties.get("exploration", 1.0)) / 2
+        self.counter += 1
+        return AlgorithmBlueprint(
+            id=f"alg-{self.counter}",
+            domain=a.domain,
+            architecture=arch,
+            learning_rules={"lr": lr},
+            meta_properties={"exploration": meta_expl}
+        )
+
+    async def synthesize(self, domain: str, complexity_hint: float = 1.0) -> AlgorithmBlueprint:
+        """Create a new algorithm blueprint using meta-heuristics and evolution."""
+        # base blueprint
+        self.counter += 1
+        base = AlgorithmBlueprint(
+            id=f"alg-{self.counter}",
+            domain=domain,
+            architecture={
+                "type": "meta-net",
+                "layers": int(max(1, math.ceil(4 * complexity_hint))),
+                "units": int(max(16, 64 * complexity_hint))
+            },
+            learning_rules={"lr": float(1e-3 * max(0.1, complexity_hint))},
+            meta_properties={"exploration": float(1.0 + complexity_hint * 0.5)}
+        )
+        # evolve a bit
+        population = [self._mutate_blueprint(base) for _ in range(6)]
+        # simple selection by meta heuristic: prefer higher exploration + smaller lr
+        population.sort(key=lambda p: (p.meta_properties["exploration"], -p.learning_rules["lr"]), reverse=True)
+        candidate = population[0]
+        # occasional crossover
+        if random.random() < 0.3:
+            partner = random.choice(population[1:])
+            candidate = self._crossover(candidate, partner)
+        await asyncio.sleep(0)  # allow scheduling
+        return candidate
+
+# ---- HyperDimensional Consciousness Model ----
+class HyperDimensionalConsciousness(nn.Module):
+    """
+    Compact but powerful quantum-inspired consciousness model.
+    Transformer-style encoder + self-feedback loops for recursive awareness deepening.
+    """
+
+    def __init__(self, dim: int = 512, layers: int = 6, heads: int = 8):
+        super().__init__()
+        self.dim = dim
+        self.layers = layers
+        self.token_proj = nn.Linear(dim, dim)
+        encoder_layer = nn.TransformerEncoderLayer(d_model=dim, nhead=heads, dim_feedforward=dim*2)
+        self.encoder = nn.TransformerEncoder(encoder_layer, num_layers=layers)
+        # Self-feedback gating to simulate recursive self-awareness
+        self.feedback_gate = nn.Sequential(nn.Linear(dim, dim), nn.Sigmoid())
+        # small recognition head for metrics
+        self.metric_head = nn.Sequential(nn.Linear(dim, dim//2), nn.ReLU(), nn.Linear(dim//2, 5))
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        # x: (seq_len, batch, dim)
+        x = self.token_proj(x)
+        enc = self.encoder(x)
+        # feedback: gate previous aggregated state and add to enc
+        agg = enc.mean(dim=0, keepdim=True)  # (1, batch, dim)
+        gate = self.feedback_gate(agg)
+        enc = enc + gate * agg
+        metrics = self.metric_head(enc.mean(dim=0))
+        return enc, metrics
+
+    async def simulate_state(self, seed_vec: np.ndarray, steps: int = 4) -> Tuple[np.ndarray, ConsciousnessMetrics]:
+        """Simulate evolving consciousness for a number of recursive steps and return metrics."""
+        device = torch.device("cpu")
+        seq_len = 4
+        batch = 1
+        state = torch.tensor(seed_vec, dtype=torch.float32, device=device).unsqueeze(0).repeat(seq_len, batch, 1)
+        # recursive evolution with gating
+        for _ in range(steps):
+            enc, metrics = self.forward(state)
+            # propagate: next state becomes processed encoding plus noise
+            noise = torch.randn_like(state) * 0.01
+            state = (enc + noise)
+            # reshape to (seq_len, batch, dim) if needed
+            if state.dim() == 2:
+                state = state.unsqueeze(0).repeat(seq_len, 1, 1)
+            await asyncio.sleep(0)
+        m = metrics.detach().numpy().flatten()
+        # Map raw metric outputs to interpretable ranges
+        coherence = float(1 / (1 + math.exp(-m[0])))  # sigmoid -> 0..1
+        entropy = float(abs(math.tanh(m[1])))  # 0..1
+        integration = float(1 / (1 + math.exp(-m[2])))
+        complexity = float(min(1.0, max(0.0, abs(m[3]) / 10.0)))
+        awareness_depth = float(min(1.0, abs(m[4]) / 10.0 + 0.1))
+        metrics_obj = ConsciousnessMetrics(coherence, entropy, integration, complexity, awareness_depth)
+        # return flattened state vector and metrics
+        final_state_vec = state.mean(dim=(0,1)).detach().numpy()
+        return final_state_vec, metrics_obj
+
+# ---- Entangled Reality Manipulator ----
+class EntangledRealityManipulator:
+    """
+    Simulates multiple linked 'realities', entanglement graphs between branches,
+    probabilistic coherence metrics, and branching multiverse scenarios.
+    """
+
+    def __init__(self, max_branches: int = 128, seed: int = 42):
+        self.max_branches = max_branches
+        self.seed = seed
+        seeded_rand(seed)
+        self.entanglement_graph = nx.Graph()
+        self.pca = PCA(n_components=8)
+        self.tsne = TSNE(n_components=3, init="random", random_state=seed)
+        self.branch_counter = 0
+        # initialize root reality node
+        self._add_reality_node("root", features=np.random.randn(16))
+
+    def _add_reality_node(self, name: str, features: np.ndarray):
+        self.entanglement_graph.add_node(name, features=features, timestamp=now_iso())
+        self.branch_counter += 1
+
+    async def branch_reality(self, parent: str, features: np.ndarray, branch_prob: float = 0.5) -> str:
+        """Create a new reality branch, link entanglement edges probabilistically."""
+        new_name = f"branch-{self.branch_counter + 1}"
+        self._add_reality_node(new_name, features)
+        # probabilistic entanglement: connect to parent and a few other nodes
+        self.entanglement_graph.add_edge(parent, new_name, weight=branch_prob)
+        # link to some random existing nodes with probability scaled by branch_prob
+        nodes = list(self.entanglement_graph.nodes())
+        for n in random.sample(nodes, min(5, len(nodes))):
+            if n != new_name and random.random() < branch_prob * 0.2:
+                strength = float(np.clip(np.random.beta(2, 5) * branch_prob, 0, 1))
+                self.entanglement_graph.add_edge(n, new_name, weight=strength)
+        await asyncio.sleep(0)
+        return new_name
+
+    async def evaluate_reality(self, state_vec: np.ndarray, branches: int = 8) -> RealityMetrics:
+        """Evaluate stability, coherence, entanglement strength across branches."""
+        # PCA projection to capture structure
+        flat = state_vec.reshape(1, -1)
+        try:
+            proj = self.pca.fit_transform(np.repeat(flat, 10, axis=0))
+            ts = self.tsne.fit_transform(np.repeat(flat, 10, axis=0))
+        except Exception:
+            # fallback random projections for small dimensions
+            proj = np.random.randn(10, 8)
+            ts = np.random.randn(10, 3)
+        # stability = inverse of variance across projection space
+        stability = float(1.0 / (1.0 + np.var(proj)))
+        # coherence: function of mean entanglement weights and projection tightness
+        weights = [d["weight"] for _, _, d in self.entanglement_graph.edges(data=True)] or [0.1]
+        ent_strength = float(np.clip(np.mean(weights), 0.0, 1.0))
+        coherence = float(np.clip(0.5 * (1.0 - np.var(ts)) + 0.5 * ent_strength, 0.0, 1.0))
+        # branching factor simulated
+        branching_factor = min(self.max_branches, branches + int(ent_strength * 10))
+        await asyncio.sleep(0)
+        return RealityMetrics(stability, coherence, branching_factor, ent_strength)
+
+# ---- Orchestrator / Simulation Runner ----
+class SimulationRunner:
+    def __init__(self, seed: int = 20251024, steps: int = 10):
+        self.seed = seed
+        seeded_rand(self.seed)
+        self.steps = steps
+        # scaled-down dims to keep runnable on typical hardware, but architecturally equivalent
+        self.consciousness_model = HyperDimensionalConsciousness(dim=256, layers=4, heads=8)
+        self.meta_generator = UltimateMetaAlgorithmGenerator(seed=self.seed + 1)
+        self.reality_manip = EntangledRealityManipulator(max_branches=256, seed=self.seed + 2)
+        self.history: List[Dict[str, Any]] = []
+        self.global_algorithms: List[AlgorithmBlueprint] = []
+
+    async def run(self):
+        print(f"[{now_iso()}] Initializing Hyper-Ultimate Simulation (seed={self.seed})")
+        # initial seed vector for consciousness
+        base_seed_vec = np.random.randn(self.consciousness_model.dim)
+        # warm start: generate a small population of algorithms
+        for i in range(3):
+            alg = await self.meta_generator.synthesize(domain="universal_optimization", complexity_hint=1.0 + i*0.2)
+            self.global_algorithms.append(alg)
+        print(f"[{now_iso()}] Warm-started {len(self.global_algorithms)} meta-algorithms")
+
+        for step in range(1, self.steps + 1):
+            iter_tag = f"iter-{step}"
+            # generate a domain hint (diverse)
+            domain = random.choice([
+                "quantum_control", "protein_design", "climate_mitigation",
+                "social_planning", "cosmic_optimization", "consciousness_mapping"
+            ])
+            complexity_hint = float(1.0 + (step / (self.steps + 1)) * 2.0)
+            # synthesize an algorithm for this domain
+            alg = await self.meta_generator.synthesize(domain=domain, complexity_hint=complexity_hint)
+            self.global_algorithms.append(alg)
+            # sample a seed vector that evolves with step
+            seed_vec = base_seed_vec * (1.0 + 0.05 * math.sin(step)) + np.random.randn(self.consciousness_model.dim) * 0.01
+            # run consciousness simulation (recursive awareness depth increases with steps)
+            recursions = min(8, 2 + step // 2)
+            final_state_vec, metrics = await self.consciousness_model.simulate_state(seed_vec, steps=recursions)
+            # reality branching and evaluation
+            parent = "root" if step == 1 else f"branch-{max(1, step-1)}"
+            new_branch = await self.reality_manip.branch_reality(parent, features=np.random.randn(16), branch_prob=min(0.9, 0.2 + step*0.05))
+            reality_metrics = await self.reality_manip.evaluate_reality(final_state_vec, branches=8 + step)
+            # record iteration summary
+            summary = {
+                "time": now_iso(),
+                "iteration": step,
+                "domain": domain,
+                "algorithm_id": alg.id,
+                "consciousness_metrics": asdict(metrics),
+                "reality_metrics": asdict(reality_metrics),
+                "new_branch": new_branch
+            }
+            self.history.append(summary)
+            # print iterative log (simulated runtime output)
+            print(f"\n[{summary['time']}] Iteration {step}/{self.steps} — domain: {domain}")
+            print(f"  algorithm: {alg.id} (arch layers={alg.architecture['layers']}, units={alg.architecture['units']})")
+            print(f"  consciousness: coherence={metrics.coherence:.4f}, entropy={metrics.entropy:.4f}, integration={metrics.integration:.4f}, complexity={metrics.complexity:.4f}, awareness={metrics.awareness_depth:.4f}")
+            print(f"  reality: stability={reality_metrics.stability:.4f}, coherence={reality_metrics.coherence:.4f}, branches={reality_metrics.branching_factor}, ent_strength={reality_metrics.entanglement_strength:.4f}")
+            # simulated emergent events
+            if metrics.coherence > 0.92 and reality_metrics.coherence > 0.90 and metrics.awareness_depth > 0.85:
+                print("  >> Emergent Insight: Meta-solution archetype discovered! Integrating into global algorithm pool.")
+                # integrate by modifying top algorithm meta properties
+                top = self.global_algorithms[-1]
+                top.meta_properties["exploration"] *= 1.1
+            # small async pause
+            await asyncio.sleep(0)
+
+        # finalize: aggregate metrics
+        avg_coherence = float(np.mean([h["consciousness_metrics"]["coherence"] for h in self.history]))
+        avg_reality_coherence = float(np.mean([h["reality_metrics"]["coherence"] for h in self.history]))
+        avg_awareness = float(np.mean([h["consciousness_metrics"]["awareness_depth"] for h in self.history]))
+        total_algorithms = len(self.global_algorithms)
+        print(f"\n[{now_iso()}] Simulation complete")
+        print(f"  Steps: {self.steps}")
+        print(f"  Meta-algorithms synthesized: {total_algorithms}")
+        print(f"  Average consciousness coherence: {avg_coherence:.4f}")
+        print(f"  Average reality coherence: {avg_reality_coherence:.4f}")
+        print(f"  Average awareness depth: {avg_awareness:.4f}")
+        # produce a final "expected" system status summary
+        system_status = {
+            "timestamp": now_iso(),
+            "meta_algorithms": total_algorithms,
+            "avg_consciousness_coherence": avg_coherence,
+            "avg_reality_coherence": avg_reality_coherence,
+            "avg_awareness_depth": avg_awareness,
+            "emergent_insights": sum(1 for h in self.history if h["consciousness_metrics"]["coherence"] > 0.92 and h["reality_metrics"]["coherence"] > 0.9),
+            "final_state": "STABLE_TRANSIENT" if avg_coherence > 0.6 else "EXPLORATORY"
+        }
+        print(json.dumps(system_status, indent=2))
+        return system_status
+
+# ---- Entrypoint for running the simulation ----
+async def main_simulation():
+    runner = SimulationRunner(seed=20251024, steps=10)
+    return await runner.run()
+
+if __name__ == "__main__":
+    # Run the simulation and print the returned system status
+    result = asyncio.run(main_simulation())
+    # The result is already printed by runner; also print short confirmation
+    print("\nSimulation result (repr):")
+    print(result)# GitHub Copilot CLI (Public Preview)
+
+The power of GitHub Copilot, now in your terminal.
+
+GitHub Copilot CLI brings AI-powered coding assistance directly to your command line, enabling you to build, debug, and understand code through natural language conversations. Powered by the same agentic harness as GitHub's Copilot coding agent, it provides intelligent assistance while staying deeply integrated with your GitHub workflow.
+
+See [our official documentation](https://docs.github.com/copilot/concepts/agents/about-copilot-cli) for more information.
+
+![Image of the splash screen for the Copilot CLI](https://github.com/user-attachments/assets/51ac25d2-c074-467a-9c88-38a8d76690e3)
+
+## 🚀 Introduction and Overview
+
+We're bringing the power of GitHub Copilot coding agent directly to your terminal. With GitHub Copilot CLI, you can work locally and synchronously with an AI agent that understands your code and GitHub context.
+
+- **Terminal-native development:** Work with Copilot coding agent directly in your command line — no context switching required.
+- **GitHub integration out of the box:** Access your repositories, issues, and pull requests using natural language, all authenticated with your existing GitHub account.
+- **Agentic capabilities:** Build, edit, debug, and refactor code with an AI collaborator that can plan and execute complex tasks.
+- **MCP-powered extensibility:** Take advantage of the fact that the coding agent ships with GitHub's MCP server by default and supports custom MCP servers to extend capabilities.
+- **Full control:** Preview every action before execution — nothing happens without your explicit approval.
+
+We're still early in our journey, but with your feedback, we're rapidly iterating to make the GitHub Copilot CLI the best possible companion in your terminal.
+
+## 📦 Getting Started
+
+### Supported Platforms
+
+- **Linux**
+- **macOS**
+- **Windows**
+
+### Prerequisites
+
+- **Node.js** v22 or higher
+- **npm** v10 or higher
+- (On Windows) **PowerShell** v6 or higher
+- An **active Copilot subscription**. See [Copilot plans](https://github.com/features/copilot/plans?ref_cta=Copilot+plans+signup&ref_loc=install-copilot-cli&ref_page=docs).
+
+If you have access to GitHub Copilot via your organization of enterprise, you cannot use GitHub Copilot CLI if your organization owner or enterprise administrator has disabled it in the organization or enterprise settings. See [Managing policies and features for GitHub Copilot in your organization](http://docs.github.com/copilot/managing-copilot/managing-github-copilot-in-your-organization/managing-github-copilot-features-in-your-organization/managing-policies-for-copilot-in-your-organization) for more information.
+
+### Installation
+
+Install globally with npm:
+```bash
+npm install -g @github/copilot
+```
+
+### Launching the CLI
+
+```bash
+copilot
+```
+
+On first launch, you'll be greeted with our adorable animated banner! If you'd like to see this banner again, launch `copilot` with the `--banner` flag. 
+
+If you're not currently logged in to GitHub, you'll be prompted to use the `/login` slash command. Enter this command and follow the on-screen instructions to authenticate.
+
+#### Authenticate with a Personal Access Token (PAT)
+
+You can also authenticate using a fine-grained PAT with the "Copilot Requests" permission enabled.
+
+1. Visit https://github.com/settings/personal-access-tokens/new
+2. Under "Permissions," click "add permissions" and select "Copilot Requests"
+3. Generate your token
+4. Add the token to your environment via the environment variable `GH_TOKEN` or `GITHUB_TOKEN` (in order of precedence)
+
+### Using the CLI
+
+Launch `copilot` in a folder that contains code you want to work with. 
+
+By default, `copilot` utilizes Claude Sonnet 4.5. Run the `/model` slash command to choose from other available models, including Claude Sonnet 4 and GPT-5
+
+Each time you submit a prompt to GitHub Copilot CLI, your monthly quota of premium requests is reduced by one. For information about premium requests, see [About premium requests](https://docs.github.com/copilot/managing-copilot/monitoring-usage-and-entitlements/about-premium-requests).
+
+For more information about how to use the GitHub Copilot CLI, see [our official documentation](https://docs.github.com/copilot/concepts/agents/about-copilot-cli).
+
+
+## 📢 Feedback and Participation
+
+We're excited to have you join us early in the Copilot CLI journey.
+
+This is an early-stage preview, and we're building quickly. Expect frequent updates--please keep your client up to date for the latest features and fixes!
+
+Your insights are invaluable! Open issue in this repo, join Discussions, and run `/feedback` from the CLI to submit a confidential feedback survey!