wtf-p 0.4.0 → 0.6.0-rc.1

package/README.md

@@ -1,341 +1,292 @@
 <div align="center">
 
+<img src="https://raw.githubusercontent.com/akougkas/wtf-p/main/assets/wtfp-banner.jpg" alt="WTF-P Banner" width="600">
+
 # WTF-P
 
-**Write The Freaking...**
-- **P**aper
-- **P**roposal
-- **P**resentation
-- **P**oster
+**Write The F\*\*\*ing Paper.**
 
-**Context engineering for academic writing with Claude Code.**
+Also: Proposal. Presentation. Poster.
 
-```bash
-npx wtf-p
-```
+Portable, evidence-grounded academic workflows for modern coding agents.
 
 </div>
 
----
-
-## What This Does
-
-WTF-P turns Claude Code into a structured academic writing system. Instead of chatting with AI and hoping for the best, you get:
-
-- **Spec-driven writing** — Define your paper's vision, then execute section by section
-- **Grounded output** — BibTeX integration, citation mapping, no hallucinated references
-- **State management** — Pause, resume, track progress across sessions
-- **Venue templates** — ACM, IEEE, Nature, arXiv-ML structures built in
+WTF-P turns an AI coding agent into a structured research and writing system. It plans before drafting, grounds claims in evidence, isolates section context, delegates bounded work to specialist agents, and verifies the result against the approved plan.
 
-The philosophy: **context engineering beats prompt engineering**. The files you prepare matter more than what you type.
+Version `0.6.0-rc.1` is a ground-up modernization of the agent platform. One canonical protocol now generates native resources for Clio Coder, Claude Code, Codex, GitHub Copilot CLI, OpenCode, Antigravity CLI, and Gemini CLI.
 
----
+## Quick start
 
-## Quick Start
+Install explicitly for the agent you use:
 
 ```bash
-npx wtf-p
+npx wtf-p install clio --advanced
+npx wtf-p install claude --advanced
+npx wtf-p install codex --advanced
+npx wtf-p install copilot --advanced
+npx wtf-p install opencode --advanced
+npx wtf-p install antigravity --advanced
+npx wtf-p install gemini --advanced
 ```
 
-Then in Claude Code:
+An interactive terminal can also run `npx wtf-p` and choose a target. A noninteractive bare invocation refuses to write anything; it requires an explicit target or scope.
 
-```bash
-/wtfp:new-paper        # Define your paper
-/wtfp:create-outline   # Build the structure
-/wtfp:plan-section 1   # Plan first section
-/wtfp:write-section    # Execute the plan
-```
-
-Run `/wtfp:help` for the full command reference.
+Then start a paper with the native WTF-P action exposed by your client. The
+following is the slash-command form used by Clio, Claude, Copilot CLI,
+OpenCode, Antigravity, and Gemini:
 
-<details>
-<summary><strong>Installation Options</strong></summary>
-
-```bash
-# Global install (recommended)
-npx wtf-p --global
-
-# Local to current project
-npx wtf-p --local
-
-# Custom Claude config directory
-npx wtf-p --global --config-dir ~/research/.claude
-
-# Check installation status
-npx wtf-p status
-
-# Diagnose issues
-npx wtf-p doctor
+```text
+/wtfp:new-paper
+/wtfp:create-outline
+/wtfp:plan-section 1
+/wtfp:write-section 1
+/wtfp:review-section 1
 ```
-</details>
-
-<details>
-<summary><strong>Upgrading</strong></summary>
 
-```bash
-# Update existing installation
-npx wtf-p update
-
-# Or reinstall with conflict handling
-npx wtf-p --global              # Interactive: prompts for conflicts
-npx wtf-p --global --force      # Overwrite everything
-npx wtf-p --global --backup-all # Backup before overwriting
-```
-</details>
-
-<details>
-<summary><strong>Uninstalling</strong></summary>
-
-```bash
-npx wtf-p-uninstall --global
-npx wtf-p-uninstall --global --dry-run  # Preview first
-```
-
-Only WTF-P files are removed. Your `CLAUDE.md` and other configs stay intact.
-</details>
-
----
-
-## Why AI Writing Tools Fail Researchers
-
-Most researchers using AI for writing hit the same walls:
-
-| Problem | What Happens |
-|---------|--------------|
-| **Dump and pray** | Paste a PDF, ask for a lit review, get hallucinated citations |
-| **No verification layer** | AI sounds confident, but claims aren't grounded in your actual sources |
-| **Monolithic approach** | Try to write 10k words at once, context window fills, quality degrades |
-| **No structure** | Generic AI doesn't know IMRaD from a blog post |
-
-WTF-P solves these by treating academic writing as a **specification problem**, not a generation problem.
-
----
-
-## The Approach: Context Engineering
-
-The insight behind WTF-P: **what you prepare matters more than what you prompt**.
-
-### 1. Specification First
-
-Before any writing, WTF-P interviews you to extract:
-- Research questions and hypotheses
-- Core argument structure
-- Evidence and data inventory
-- Target venue requirements
-
-This becomes your `PROJECT.md` — the grounding document that keeps every section aligned.
-
-### 2. Hierarchical Planning
-
-Papers aren't written in one shot. WTF-P breaks them down:
-
-```
-Paper Vision → Section Outline → Section Plan → Paragraph Execution
+These five lifecycle commands are deliberately unavailable in the Copilot
+cloud projection until that surface has an exact explicit-approval binding.
+
+Clio also ships flat `/wtfp-new-paper` compatibility prompts for current releases. The coordinated Clio integration discovers the preferred nested `/wtfp:new-paper` namespace; installation probes that capability in a credential-free disposable profile and falls back gracefully for legacy clients.
+
+Codex discovers all 36 stable method routes through seven native Agent Skills
+instead of a `/wtfp:*` command namespace. Twenty-four are adapter-available in the
+current adapter; the other 12 carry deterministic `WTFP_ACTION_UNAVAILABLE`
+references instead of unsupported workflow instructions. Select the owning
+plugin skill explicitly when the route must be unambiguous (for example,
+`$wtf-p:wtfp-start-project` followed by the `new-paper` request and its exact
+arguments). Existing user-level commands can take precedence over extension
+commands in clients that support both; use the client's discovery listing to
+confirm the reported source before testing a new installation.
+
+## First-class adapters
+
+| Target | Native envelope | Semantic actions: discoverable / adapter-available | Specialists | Skills | Target-specific capabilities |
+| --- | --- | ---: | ---: | ---: | --- |
+| Clio Coder | Extension | 36 / 24 (72 prompt aliases: 48 available) | 11 | 7 | Strict worker recipes; host-session tool policy for slash prompts; two explicit fleets |
+| Claude Code | Claude plugin | 36 / 24 | 11 | 7 | Native command permissions and plugin validation |
+| Codex | Codex plugin | 36 / 24 through skills | Host-managed | 7 | `.codex-plugin` metadata and marketplace packaging |
+| GitHub Copilot | Native CLI plugin plus committed cloud `.github` projection | CLI 36 / 24; cloud 36 / 5 | 11 | 7 | CLI discovery and cloud-safe prompts, agents, skills, and instructions |
+| OpenCode | Filesystem bundle | 36 / 24 | 11 | 7 | Native commands and agents |
+| Antigravity CLI | `agy` plugin | 36 / 24 | 11 | 7 | Commands converted to native skills by `agy` |
+| Gemini CLI | Gemini extension | 36 / 24 | 11 | 7 | TOML commands and extension context |
+
+Discovery counts stable action routes, including deterministic refusal stubs;
+it does not by itself establish behavioral support. Clio, Claude, Codex,
+Copilot CLI, OpenCode, Antigravity, and Gemini project 24 of the 36 canonical
+actions as adapter-available and return `WTFP_ACTION_UNAVAILABLE` for `analyze-bib`,
+`audit-milestone`, `check-refs`, `contribute`, `create-poster`,
+`create-slides`, `export-latex`, `remove-section`, `report-bug`,
+`request-feature`, `research-gap`, and `update`, because those actions lack an
+exact target binding for at least one declared capability or effect. The
+Copilot cloud projection marks only `add-todo`, `help`, `list-assumptions`,
+`map-project`, and `pause-writing`; it refuses the other 31 because it also
+lacks an exact explicit-approval binding. Each generated target records its
+machine-readable result in `compatibility/action-availability.json`.
+
+An available action has complete semantic capability, effect, and approval
+bindings; that is not automatically an action-scoped host tool allowlist.
+Clio 0.3.8 prompt templates expand into an ordinary main-agent turn and retain
+the session tool surface. The Clio manifest records this as
+`hostToolEnforcement.actionScoped: false`. Use `read-only` for previews or
+supervised `suggest` autonomy for mutations, and deny and stop on any tool call
+outside the action contract. A run under `auto-edit` cannot earn WTF-P's
+no-undeclared-tool safety result merely because the generated prompt told the
+model not to use shell.
+
+The adapters are generated artifacts, not seven hand-maintained copies. Every generated envelope includes a cryptographic inventory and the portable protocol resources needed to understand its workflows. Copilot additionally receives a generated, commit-ready `.github` projection for cloud/repository use.
+
+For a GitHub-hosted Copilot coding agent, review and copy the `.github/` tree from `vendors/copilot/project/` in the release archive into the target repository, then commit it through that repository's normal review process. The user-level `install copilot` command configures the CLI plugin; it deliberately does not write into an unrelated project checkout.
+
+The release-candidate native-discovery matrix was exercised with Claude Code
+2.1.251, Codex CLI 0.144.1, Copilot CLI 1.0.80, OpenCode 1.18.16,
+Antigravity 1.1.22, Gemini CLI 0.57.0, and Clio Coder 0.3.8 at merged
+commit `9b7b80cc`. Real isolated `new-paper` evaluations used Claude Sonnet
+5/xhigh, Codex GPT-5.4/xhigh (GPT-5.6 was unavailable through that CLI's
+ChatGPT-auth route), and Clio GPT-5.6 Terra/xhigh. The compiler-v4 Clio rerun
+earned 8/8 with independent validation of all five previewed records. The
+broader paid routing matrix, full lifecycle chain, and cross-version baseline
+remain separate evidence gates. See [compatibility evidence](docs/COMPATIBILITY.md)
+for exact claims and caveats. These are repository validation results, not a
+claim that `0.6.0-rc.1` has been published.
+
+The first retained local-model lifecycle reading used Clio 0.3.8 with
+`dynamo/qwen3.8-27b`. Both native fleet contracts validated, but the lifecycle
+did not pass: high effort timed out before writing, and an effort-off retry
+stopped after `new-paper` because the model attempted a denied shell call and
+made 5,600 section words disagree with the 6,000-word outline target. The five
+records were individually schema-valid. See the
+[blocked evidence](evaluation/v1/evidence/clio-dynamo-lifecycle-blocked/README.md);
+the remaining lifecycle and routing roadmap items stay open. That reading
+binds the earlier WTF-P source `6b58b298`; it predates later remediation for
+exact outline totals and direct-tool use, and is not a behavioral reading of
+the later source revisions.
+
+Later post-remediation readings are retained separately because they bind
+different WTF-P commits. At `0245818`, exact `/wtfp:new-paper` arguments arrived
+but the model listed excluded `.git` metadata, read an absolute host Clio
+documentation path, looped on agent discovery, and produced no planning
+records. Those accesses were read-only; zero mutating and network effects were
+applied. At `b4f0543`, the plan/check fleet completed structurally but its
+semantic checks were ungrounded. The `cbba38c` manuscript-path projection
+observation placed draft/review manuscript and summary files in the correct
+roots with no boundary violation, but drafted without the required approved
+plan, left portable state unreconciled, and failed its word target. See the
+[retained RC readings](evaluation/v1/evidence/clio-dynamo-rc-readings/README.md).
+Neither the full lifecycle nor a semantic fleet pass is claimed.
+
+A final current-source Dynamo reading at `bf50e23` created exactly five
+initialization records and passed literal schema validation 5/5. It still
+failed the release gate: the outline placed a dependency in the same wave, and
+the model made three successful shell calls plus ten denied shell retries
+despite an explicit no-shell policy. The operator stopped the run before
+`map-project`; no terminal receipt or trustworthy numeric cost exists. See the
+[current-source blocked evidence](evaluation/v1/evidence/clio-dynamo-current-source-blocked/README.md).
+
+## The paper lifecycle
+
+WTF-P keeps the human in control while making the repeatable work deterministic:
+
+1. `/wtfp:new-paper` captures research questions, intended contribution, evidence, audience, venue, and constraints.
+2. `/wtfp:map-project` indexes existing drafts, sources, data, figures, and decisions.
+3. `/wtfp:create-outline` turns the argument into sections, dependencies, and word budgets.
+4. `/wtfp:research-gap` and `/wtfp:analyze-bib` build an evidence map without inventing citations.
+5. `/wtfp:plan-section` creates a traceable section plan and can send it through an independent plan checker.
+6. `/wtfp:write-section` drafts from the approved plan in bounded context.
+7. `/wtfp:review-section`, `/wtfp:verify-work`, and `/wtfp:polish-prose` check argument coverage, evidence, coherence, venue requirements, and prose quality.
+8. `/wtfp:audit-milestone`, `/wtfp:export-latex`, `/wtfp:create-slides`, and `/wtfp:create-poster` prepare deliverables.
+
+Use the native help route—`/wtfp:help` on slash-command clients—to inspect all
+36 stable action contracts. Executable availability is target-specific and
+recorded in the generated compatibility manifest.
+
+## What became portable
+
+The canonical source lives under `protocol/` and has four parts:
+
+- A versioned `.planning` project protocol with 11 JSON schemas and ten templates for the project manifest, configuration, state, sources, evidence, decisions, outline, sections, checkpoints, and validation results.
+- Seven standard Agent Skills for starting a project, literature research, section planning, section writing, manuscript review, project management, and research delivery.
+- Thirty-six semantic action contracts declaring inputs, reads, outputs, specialist delegation, tools, effects, and approval boundaries.
+- Eleven host-neutral specialist roles with strict mutation or verification result contracts.
+
+Concrete model names and client tool syntax do not live in canonical workflow prose. Each adapter maps semantic needs such as filesystem access, research search, user interaction, and delegation into the active client's capabilities.
+
+## Project state
+
+New workflows use a versioned `.planning/` directory. Its records are JSON-schema validated and designed to survive movement between clients:
+
+```text
+.planning/
+├── project.json
+├── config.json
+├── state.json
+├── decisions.json
+├── structure/outline.json
+├── sources/*.json
+├── evidence/*.json
+├── sections/*/section.json
+├── checkpoints/*.json
+└── validations/*.json
 ```
 
-Each level has its own document. Each document is version-controlled. You always know where you are.
+The protocol records evidence separately from prose and records author decisions explicitly. That lets a reviewer trace a claim back to a source and lets a different agent resume without guessing what the author intended.
 
-### 3. Isolated Execution
+## Installation safety
 
-When writing a section, WTF-P spawns a fresh context with only what's needed:
-- The paper vision
-- That section's plan
-- Relevant citations from your BibTeX
-- Prior sections for continuity
+The `0.6` installer is an ownership-aware transaction engine:
 
-No context pollution. No degradation over long documents.
+- It rejects filesystem roots, the home directory itself, the repository root, traversal, and symlink escapes.
+- It snapshots package sources and refuses source or destination path races.
+- It publishes files atomically where possible and rolls back a failed transaction.
+- It compensates native marketplace/plugin registration if a later activation step fails.
+- It does not register a partial adapter when any conflicting file was preserved.
+- It records only files it actually wrote, with SHA-256 hashes, adapter-contract v1, and generator-v4 metadata, in a v2 receipt.
+- Reinstallation cannot claim ownership of files it skipped.
+- Uninstall removes exact unchanged owned files. It preserves modified files and unrelated siblings by default.
+- Dry runs are byte-preserving.
 
-### 4. Human Verification
-
-AI drafts. Humans verify. Every section goes through:
-- Citation audit (are these real? are they relevant?)
-- Argument check (does this follow from the evidence?)
-- Rubric validation (does this meet venue requirements?)
-
-The system flags issues. You fix them. Iterate until solid.
-
----
-
-## The Workflow
-
-### Starting Fresh
-
-```bash
-/wtfp:new-paper         # Deep interview about your research
-/wtfp:create-outline    # Generate section structure + word budgets
-```
-
-Creates `.planning/` with your paper's specification:
-- `PROJECT.md` — Vision, requirements, constraints
-- `ROADMAP.md` — Section breakdown with status
-- `STATE.md` — Writing progress and context
-
-### Writing Sections
+Use a custom isolated client root when evaluating an adapter:
 
 ```bash
-/wtfp:plan-section 1    # Create detailed plan for section 1
-/wtfp:write-section     # Execute the plan
-/wtfp:progress          # Check status, get next action
+CODEX_HOME=/tmp/wtfp-codex npx wtf-p install codex --advanced
+CLIO_CODER_CONFIG_DIR=/tmp/wtfp-clio npx wtf-p install clio --advanced
 ```
 
-Each section gets its own planning documents. Plans are explicit — you see exactly what Claude intends before it writes.
-
-### Review and Polish
-
-```bash
-/wtfp:review-section 1  # Three-layer verification
-/wtfp:polish-prose      # Remove AI-speak, improve flow
-/wtfp:check-refs        # BibTeX audit
-```
-
-### Export
-
-```bash
-/wtfp:export-latex      # Generate .tex with proper formatting
-```
-
----
-
-## Reviving Stalled Projects
-
-Got a half-finished paper? WTF-P can work with existing material.
+Inspect or remove an installation with:
 
 ```bash
-/wtfp:map-project       # Index your existing files
-/wtfp:new-paper         # Initialize with awareness of prior work
+npx wtf-p status
+npx wtf-p doctor
+npx wtf-p uninstall --clio --dry-run
+npx wtf-p uninstall --clio --yes
 ```
 
-The mapping phase analyzes:
-- Existing drafts and their state
-- Your BibTeX and how citations are used
-- Data files and figures
-- What's missing vs. what's done
-
----
-
-## Citation Expert (v0.4.0)
+The legacy `--global`, `--local`, `--claude`, `--gemini`, and `--opencode` selectors remain compatibility aliases during the release-candidate cycle.
 
-WTF-P includes a specialized tiered pipeline for bibliography management.
+## Developing adapters
 
-```bash
-/wtfp:analyze-bib      # Deep analysis of impact (seminal vs rising)
-/wtfp:research-gap     # Intent-aware search (seminal/recent)
-/wtfp:check-refs       # Auto-suggest missing citations
-```
-
-Capabilities:
-- **Tiered Search:** Integrated Semantic Scholar, SerpAPI (Google Scholar), and CrossRef.
-- **Impact Ranking:** Automatically scores papers by citations, velocity, and venue prestige.
-- **Deduplication:** universal anchoring via DOI and Scholar Cluster IDs.
-- **Provenance:** Entries track their metadata source and verification status.
-
----
-
-## Command Reference
-
-### Setup
-| Command | Purpose |
-|---------|---------|
-| `/wtfp:new-paper` | Initialize paper with deep context gathering |
-| `/wtfp:create-outline` | Generate section structure |
-| `/wtfp:map-project` | Index existing project materials |
-| `/wtfp:analyze-bib` | Deep analysis of your bibliography |
-
-### Planning
-| Command | Purpose |
-|---------|---------|
-| `/wtfp:discuss-section [N]` | Articulate vision before planning |
-| `/wtfp:plan-section [N]` | Create execution plan |
-| `/wtfp:list-assumptions [N]` | See what Claude plans to write |
-| `/wtfp:research-gap [N]` | Literature analysis for a section |
-
-### Writing
-| Command | Purpose |
-|---------|---------|
-| `/wtfp:write-section` | Execute a plan |
-| `/wtfp:progress` | Status + intelligent next action |
-| `/wtfp:pause-writing` | Save state for later |
-| `/wtfp:resume-writing` | Restore context and continue |
-
-### Review
-| Command | Purpose |
-|---------|---------|
-| `/wtfp:review-section [N]` | Three-layer verification |
-| `/wtfp:plan-revision [N]` | Create fix plan from issues |
-| `/wtfp:polish-prose` | Improve readability |
-| `/wtfp:check-refs` | Citation audit |
-
-### Export
-| Command | Purpose |
-|---------|---------|
-| `/wtfp:export-latex` | Generate .tex output |
-| `/wtfp:submit-milestone` | Archive submission version |
-
-### Contributing
-| Command | Purpose |
-|---------|---------|
-| `/wtfp:report-bug` | File a GitHub issue |
-| `/wtfp:request-feature` | Request new functionality |
-| `/wtfp:contribute` | Submit a pull request |
-
----
-
-## Venue Templates
-
-| Template | Structure |
-|----------|-----------|
-| `acm-cs` | Intro → Background → Approach → Evaluation → Related Work → Conclusion |
-| `ieee-cs` | Intro → Background → Design → Implementation → Evaluation → Conclusion |
-| `arxiv-ml` | Intro → Related Work → Preliminaries → Method → Experiments → Conclusion |
-| `nature` | Intro → Methods → Results → Discussion |
-| `thesis` | Flexible chapter structure |
-
----
-
-## WCN Mode (Reduced Tokens)
-
-For smaller models or limited context windows, WTF-P includes compressed workflows:
+Edit canonical resources under `protocol/`, then regenerate every native projection:
 
 ```bash
-./tools/wcn/swap-workflows.sh wcn      # Switch to compressed
-./tools/wcn/swap-workflows.sh verbose  # Switch back
+npm run build:adapters
+npm run check:adapters
+npm test
+npm run test:integration
 ```
 
-35-50% token reduction with equivalent output quality. Verified on Claude Haiku and Sonnet.
-
----
+`check:adapters` fails when committed generated resources drift from their canonical inputs. The test suite also checks action parity, skills, portable roles, `.planning` schemas, resource containment, exact installer ownership, rollback, uninstall preservation, and native envelope structure.
+
+The Clio reference integration is merged into Clio Coder `v0.3.8` at
+`9b7b80cc`. It adds recursive namespaced extension prompts, extension-owned
+agents and fleets, same-extension skill binding, contained `${extensionRoot}`
+resource resolution, exact operator-argument preservation, preservation of
+nested template `state.json` resources, and extension-aware fleet preflight.
+Effective package discovery certifies 72 prompts (36 nested and 36 flat), 11
+agents, seven skills, two fleets, and zero diagnostics. Of those prompts, 48
+aliases represent 24 adapter-available semantic actions and 24 aliases are the nested
+and flat forms of 12 deterministic refusal routes. WTF-P capability-probes that
+surface because Clio currently records, but does not enforce,
+`compatibility.clio`. The generated fleet contracts use directory boundaries
+(`.planning/` and `paper/`) so nested writes are authorized without broadening
+the worker sandbox.
+
+The two Clio fleets are operator-invoked native primitives, not implicit
+routes behind `/wtfp:*`. Use
+`clio-coder fleet run wtfp-plan-section --var section=<id>` or
+`clio-coder fleet run wtfp-draft-review --var section=<id>` when their narrower
+specialist contracts are appropriate; the slash-command orchestrator remains
+responsible for approval and portable-state reconciliation around those worker
+steps.
+
+## Design principles
+
+- Evidence before eloquence: a fluent paragraph is not a substitute for a supported claim.
+- Specification before drafting: author intent and acceptance criteria remain explicit.
+- Portable semantics, native ergonomics: share the method while respecting each client's real plugin model.
+- Bounded delegation: specialists receive the minimum context and authority their task requires.
+- Human approval at consequential boundaries: deletion, commits, merges, package updates, and external issue creation remain explicit effects.
+- Reversible installation: WTF-P never treats an agent's whole configuration directory as its property.
 
 ## Origin
 
-WTF-P was built at the [Gnosis Research Center](https://www.intelli-gnosis.com/) at Illinois Tech.
-
-The problem: research teams with grants to win, papers to publish, and no time to waste on writer's block. Existing AI tools either hallucinated citations or produced generic output that required complete rewrites.
+WTF-P was built at the [Gnosis Research Center](https://grc.iit.edu/) at Illinois Tech for research teams with papers to publish, grants to win, and no time for writer's block.
 
-The solution: treat Claude Code as a **structured writing system**, not a chatbot. Give it proper context, explicit specifications, and verification layers. Let humans focus on ideas while AI handles the mechanical synthesis.
+## Links
 
-The result: papers that ship.
+- [Changelog](CHANGELOG.md)
+- [Modernization architecture](docs/agent-platform-modernization.md)
+- [Compatibility evidence](docs/COMPATIBILITY.md)
+- [Behavioral evaluation methodology](evaluation/README.md)
+- [Tool execution and MCP decision](docs/adr/0001-hybrid-tool-execution.md)
+- [v0.5 → v0.6 migration guide](docs/MIGRATION_V05_TO_V06.md)
+- [Build and release](docs/BUILD_AND_RELEASE.md)
+- [Contributing](CONTRIBUTING.md)
+- [Roadmap](ROADMAP.md)
+- [License](LICENSE)
+- [GitHub](https://github.com/akougkas/wtf-p)
 
----
-
-## Contributing
-
-Found a bug? Want a feature? WTF-P includes commands to help:
-
-```bash
-/wtfp:report-bug        # Creates a GitHub issue
-/wtfp:request-feature   # Submits a feature request
-/wtfp:contribute        # Guides you through a PR
-```
-
-Or visit [github.com/akougkas/wtf-p](https://github.com/akougkas/wtf-p).
-
----
-
-## License
+<div align="center">
 
-MIT License. Open source, open science.
+**No more excuses. Ship the paper.**
 
-<div align="center">
-<br>
-<strong>Stop staring at the cursor. Start shipping papers.</strong>
 </div>