defluffisizer 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tehila Pelled
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,113 @@
+# defluffisizer
+
+> messy draft in -> clear human copy out
+
+Strip AI sounding fluff from docs, decks, PDFs, and notes while keeping the facts, the structure, and the strongest human signal. Works as an agent skill (Claude Code, Codex, Cursor, and any harness that reads project rules) and as a standalone CLI.
+
+This repo packages `defluffisizer` in the same general shape as `paper2code`: a root README, a canonical `skills/defluffisizer/` install path, stage based skill instructions, helper scripts, guardrails, knowledge files, and worked examples.
+
+## Why this exists
+
+The problem: a lot of AI assisted writing is padded, abstract, over transitioned, and too even in tone, even when every fact in it checks out. It reads like a system trying to be helpful. It rarely reads like a person who means something specific.
+
+What naive rewriting gets wrong: many tools just paraphrase the fluff. They swap one set of vague phrases for another, smooth over real tension, and sometimes delete facts to make the text shorter.
+
+What `defluffisizer` does differently:
+
+1. Starts from deletion, not paraphrase
+2. Preserves facts, numbers, names, dates, and caveats
+3. Restores human signal such as stakes, asymmetry, and chosen detail
+4. Uses format aware workflows for decks, documents, PDFs, and text
+5. Validates rewrites with a lint pass instead of trusting surface polish
+
+## Install
+
+Install the skill straight from GitHub:
+
+```bash
+npx skills add p-tequila/defluffisizer/skills/defluffisizer
+```
+
+Or install the CLI globally from npm:
+
+```bash
+npm install -g defluffisizer
+```
+
+## Usage
+
+These are skill invocations for a skill aware agent (Claude Code, Codex, or Cursor), not raw shell commands. Ask the agent to run them, or type them if your harness treats a leading `/` as a skill trigger. For a harness with no native skill loader, paste `skills/defluffisizer/prompts/append_system_prompt.txt` in as its system prompt or project rules instead.
+
+### Full rewrite
+
+`/defluffisizer path/to/report.docx`
+
+### Review only
+
+`/defluffisizer path/to/memo.md --mode review`
+
+### Compress a long draft
+
+`/defluffisizer path/to/brief.pdf --mode compress`
+
+### Retitle a slide deck
+
+`/defluffisizer path/to/deck.pptx --mode retitle`
+
+### Generate a real rewritten PowerPoint
+
+`/defluffisizer path/to/deck.pptx --mode rewrite`
+
+### Apply a prepared PowerPoint replacement map
+
+`/defluffisizer path/to/deck.pptx --mode apply_only`
+
+### Rewrite a PDF and choose where the output goes
+
+`/defluffisizer path/to/report.pdf --output-dir ~/Desktop/clean`
+
+With no `--output-dir`, the output lands next to the source: `path/to/report_defluffed.pdf` (same format in, same format out; e.g. `deck_defluffed.pptx` for a `.pptx` source). PDF output is built from HTML via headless Chrome: plain rewritten text becomes a clean, simple page by default, or hand it a styled `.html` file as the rewritten content for a closer visual match to the source's design. Add `--output-dir DIR` to change only the directory, or name an exact file with `--output DIR/name.ext`.
+
+## What it can operate on
+
+- `.pptx` — pure Python, no extra tools, works anywhere
+- `.txt`, `.md`, `.csv`, `.tsv` — pure Python, no extra tools, works anywhere
+- `.doc`, `.docx`, `.odt`, `.rtf`, `.html` — needs macOS's built-in `textutil`; no equivalent shipped for Linux or Windows yet
+- `.pdf` — extraction needs `pdftotext` from poppler (`brew install poppler` on macOS, `apt install poppler-utils` on Debian/Ubuntu); writing a `.pdf` back out needs Google Chrome or Chromium installed, for headless rendering. Neither is bundled. Missing either fails with a clear error instead of silently doing nothing.
+
+## What you get
+
+- rewritten copy in the original format when a writer exists
+- extracted text or JSON when layout preserving writeback is not available
+- optional lint output comparing before and after
+- worked examples and review notes
+
+## What this skill will not do
+
+- invent missing facts to make prose sound more human
+- add fake informality, slang, or typos
+- rewrite formulas or spreadsheet math unless asked
+- claim layout preservation for formats where the writer does not exist yet
+
+## CLI
+
+The npm package exposes a `defluffisizer` command:
+
+```bash
+defluffisizer prompt
+defluffisizer probe path/to/file.pdf
+defluffisizer extract path/to/deck.pptx --out editable.json
+
+# writes path/to/deck_defluffed.pptx, next to the source, by default
+defluffisizer apply path/to/deck.pptx editable.json
+
+# --output-dir keeps the default name, changes the directory
+defluffisizer apply path/to/deck.pptx editable.json --output-dir ~/Desktop/out
+
+# --output overrides both name and directory
+defluffisizer apply path/to/deck.pptx editable.json --output final/deck.pptx
+
+defluffisizer lint --before before.txt --after after.txt
+```
+
+

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "defluffisizer",
+  "version": "1.0.0",
+  "description": "Portable skill and CLI for removing AI sounding fluff from decks, docs, PDFs, and notes while keeping the facts.",
+  "type": "module",
+  "author": "Tehila Pelled",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/p-tequila/defluffisizer.git"
+  },
+  "homepage": "https://github.com/p-tequila/defluffisizer#readme",
+  "bugs": {
+    "url": "https://github.com/p-tequila/defluffisizer/issues"
+  },
+  "bin": {
+    "defluffisizer": "skills/defluffisizer/bin/defluffisizer.js"
+  },
+  "scripts": {
+    "check:pack": "npm pack --dry-run --cache ./.npm-cache",
+    "check:cli": "node ./skills/defluffisizer/bin/defluffisizer.js --help",
+    "check:probe": "node ./skills/defluffisizer/bin/defluffisizer.js probe ./README.md",
+    "check:install": "node ./skills/defluffisizer/bin/defluffisizer.js install --target ./.defluffisizer-smoke --force"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "skills/defluffisizer"
+  ],
+  "keywords": [
+    "ai",
+    "writing",
+    "editing",
+    "skill",
+    "agent-skill",
+    "codex",
+    "claude-code",
+    "cursor",
+    "pptx",
+    "docx",
+    "pdf"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  }
+}

package/skills/defluffisizer/README.md

@@ -0,0 +1,182 @@
+# Defluffisizer
+
+Defluffisizer is a portable writing skill for stripping AI sounding padding out of reports, decks, notes, PDFs, and spreadsheet text while keeping the facts.
+
+## Prerequisites
+
+- `.pptx`, `.txt`, `.md`, `.csv`, `.tsv`: none, pure Python standard library.
+- `.doc`, `.docx`, `.odt`, `.rtf`, `.html`: macOS's built-in `textutil`. macOS only for now.
+- `.pdf` extraction: `pdftotext` from poppler, not bundled. `brew install poppler` (macOS) or `apt install poppler-utils` (Debian/Ubuntu).
+- `.pdf` output: Google Chrome or Chromium, not bundled, used headless to render HTML to a real PDF.
+- Missing any of these fails with a clear error naming the tool and the install command, not a silent no-op.
+
+## What it includes
+
+- `SKILL.md` for skill aware harnesses (Claude Code, Codex, and anything that reads `npx skills add`)
+- `prompts/append_system_prompt.txt` for harnesses that accept system prompt text
+- `harnesses/generic/` for a project local scaffold that works with tools like Cursor that have no native skill loader
+- `scripts/defluff_lint.py` for before and after checks
+- `scripts/pptx_rewrite.py` to extract slide text and write a new defluffed `.pptx`
+- `scripts/document_text_io.py` for cross format extraction and apply
+- `scripts/pdf_write.py` to render HTML to a real PDF, used when apply targets `.pdf`
+- `pipeline/`, `guardrails/`, and `knowledge/` for a paper2code style stage based workflow
+- `worked/` for real before and after examples, including a full one-pager rewrite of defluffisizer's own pitch
+
+## Install
+
+### Skills CLI, paper2code style
+
+Install straight from GitHub, same path pattern as `paper2code`:
+
+```bash
+npx skills add p-tequila/defluffisizer/skills/defluffisizer
+```
+
+### Local Codex style install
+
+If you install the npm package, the `defluffisizer` CLI can install the skill into a local skills directory.
+
+```bash
+defluffisizer install --target ~/.codex/skills
+```
+
+Without the global install, you can run the published package directly:
+
+```bash
+npx defluffisizer install --target ~/.codex/skills
+```
+
+This installs the skill at `~/.codex/skills/defluffisizer`.
+
+### Claude Code
+
+Claude Code reads `SKILL.md` natively, so the GitHub or Codex style install above is enough:
+
+```bash
+npx skills add p-tequila/defluffisizer/skills/defluffisizer
+```
+
+For one off runs, or a harness that only takes a raw system prompt, Claude Code can also consume the prompt file directly:
+
+```bash
+claude -p "Defluff this text" \
+  --append-system-prompt-file skills/defluffisizer/prompts/append_system_prompt.txt
+```
+
+### Cursor
+
+Cursor has no native skill loader. Scaffold the generic bundle, then add `.defluffisizer/generic/DEFLUFFISIZER.md` as a Cursor project rule (`.cursor/rules/defluffisizer.mdc`, or **Settings → Rules → Project Rules**):
+
+```bash
+npx defluffisizer scaffold generic --target .
+```
+
+Cursor's agent can call the scripts in `.defluffisizer/skill/scripts/` directly, they are plain Python. See [Prerequisites](#prerequisites) above for what `.docx` and `.pdf` support additionally need.
+
+### Generic harnesses
+
+Scaffold a local prompt pack plus runtime bundle:
+
+```bash
+npx defluffisizer scaffold generic --target .
+```
+
+## CLI
+
+The npm package exposes these commands:
+
+```bash
+defluffisizer prompt
+defluffisizer scaffold generic --target .
+defluffisizer probe input.pdf
+defluffisizer extract input.pptx --out editable.json
+defluffisizer apply input.pptx editable.json                       # -> input_defluffed.pptx, next to input.pptx
+defluffisizer apply input.pptx editable.json --output-dir out/     # -> out/input_defluffed.pptx
+defluffisizer apply input.pptx editable.json --output exact.pptx   # -> exact.pptx
+defluffisizer lint --before before.txt --after after.txt
+```
+
+## Operations
+
+This skill supports several kinds of jobs:
+
+- full rewrite of a report, memo, deck, note, or PDF extract
+- review only, where the skill flags fluff and proposes cuts
+- compression, where the goal is a materially shorter version
+- retitle, where only slide titles, headings, bullets, and first lines are tightened
+- apply only, where a prepared replacement map is written back into a `.pptx`
+
+## Evaluate a rewrite
+
+```bash
+python3 scripts/defluff_lint.py --before before.txt --after after.txt
+```
+
+What to look for:
+
+- lower word count without missing numbers or names
+- zero em dashes
+- zero or near zero `not X, but Y` patterns
+- fewer vague buzzwords and repeated openings
+
+## Probe a file before rewriting
+
+```bash
+python3 scripts/document_text_io.py probe input.docx
+python3 scripts/document_text_io.py probe input.pptx
+python3 scripts/document_text_io.py probe input.pdf
+```
+
+## Rewrite a PowerPoint and save a real `.pptx`
+
+1. Extract editable slide text:
+
+```bash
+python3 scripts/document_text_io.py extract input.pptx --out editable.json
+```
+
+2. Rewrite the `text` fields in `editable.json` with `defluffisizer`.
+
+3. Apply the rewritten text back to the deck. With no `--output`, this writes `input_defluffed.pptx` next to `input.pptx`:
+
+```bash
+python3 scripts/document_text_io.py apply input.pptx editable.json
+```
+
+Add `--output-dir some/dir` to keep that name but change the directory, or `--output exact/path.pptx` to name it yourself. This preserves the slide order, text boxes, and table cells that already exist in the deck.
+
+## Rewrite Word style documents
+
+```bash
+python3 scripts/document_text_io.py extract input.docx --out extracted.txt
+python3 scripts/document_text_io.py apply input.docx rewritten.txt
+# -> input_defluffed.docx, next to input.docx
+```
+
+This preserves content. Layout fidelity is best effort.
+
+## Rewrite PDFs
+
+```bash
+python3 scripts/document_text_io.py extract input.pdf --out extracted.txt
+python3 scripts/document_text_io.py apply input.pdf rewritten.txt
+# -> input_defluffed.pdf, next to input.pdf: same format in, same format out
+```
+
+PDF output is built from HTML via headless Chrome (`scripts/pdf_write.py`), not a byte-level edit of the original PDF. Two ways to apply:
+
+- `rewritten.txt` is plain text: wrapped in a minimal, clean, single-column page. Faithful to the words, not to the source's original design.
+- `rewritten.html` is a styled HTML file you built: rendered as-is. Use this to recreate a source with real visual design (colors, tables, callout boxes) — write the HTML by hand with the defluffed content, matching the source's layout and colors, then apply with that `.html` file as REWRITTEN.
+
+Use `--output-dir` or `--output` the same way as any other format to change where it lands or what it's named. Ask for `.docx` or `.txt` output instead if you don't need a PDF back.
+
+## Demo material
+
+- See `references/evaluation_playbook.md` for a repeatable review flow
+- See `worked/defluffisizer_one_pager/` for a full before and after: a one-pager about defluffisizer itself, written as YC-startup fluff, then defluffed. Real styled PDFs, real lint numbers.
+
+## Harness notes
+
+- Claude Code and Codex, and anything else that reads `npx skills add`, can use `SKILL.md` directly.
+- Any other harness, Cursor included, can use `harnesses/generic/DEFLUFFISIZER.md` or the raw prompt file as system instructions.
+- For harnesses that can run shell tools, the bundled Python scripts provide extraction, writeback, and linting.

package/skills/defluffisizer/SKILL.md

@@ -0,0 +1,128 @@
+---
+name: defluffisizer
+description: "Rewrites documents, decks, notes, PDFs, and spreadsheet text to remove AI sounding fluff while preserving facts, structure, and the strongest human signal. Trigger when the user asks to defluff, tighten, review, shorten, retitle, or rewrite a file or pasted text."
+---
+
+# defluffisizer - Orchestration
+
+You are executing the `defluffisizer` skill. This file governs the high level flow. Use the pipeline files for substantial jobs. Do not jump straight to line edits when the source is a document, deck, PDF, or spreadsheet export.
+
+This skill is for prose cleanup inside documents, notes, reports, slide decks, speaker notes, PDFs, and spreadsheet text. It is not for inventing evidence, changing formulas, changing table math, or padding the output.
+
+## Parse arguments
+
+Extract from the user request:
+
+- `SOURCE`: a file path, pasted text, or a set of cells or slides
+- `MODE`: one of `rewrite` (default), `review`, `compress`, `retitle`, `apply_only`
+- `AGGRESSION`: one of `light`, `standard` (default), `hard`
+- `OUTPUT`: source format when safe, otherwise text or markdown
+- `OUTPUT_DIR`: where the final file lands. Default is the same directory as `SOURCE`. Only override this when the user names a directory (`--output-dir path/`, or "save it to X").
+- `PRESERVE_LAYOUT`: `true` by default for `.pptx`, best effort for other formats
+
+For a file source, the default output name is always `{source_stem}_defluffed{output_ext}`, where `output_ext` is the source's own extension. Same format in, same format out, `.pdf` included. Do not invent a different name or drop the `_defluffed` suffix unless the user explicitly asks for a specific filename.
+
+For a `.pdf` source, applying straight text as REWRITTEN produces a plain, clean, single-column PDF, faithful to the words but not the source's original design. If the source has real visual design worth recreating (colors, tables, callout boxes, a branded header), build a styled `.html` file with the defluffed content instead, matching the source's layout and colors, and pass that `.html` file as REWRITTEN so it renders as-is. See [knowledge/format_capabilities.md](knowledge/format_capabilities.md) for both paths.
+
+Interpret the modes this way:
+
+- `rewrite`: defluff the whole source while preserving meaning
+- `review`: flag the fluff and explain the cuts without rewriting everything
+- `compress`: shorten aggressively while preserving the core claims
+- `retitle`: rewrite only titles, headings, bullets, and topic sentences
+- `apply_only`: apply a prepared replacement map back into a file
+
+## Set up working directory
+
+Create a temporary work directory:
+
+`.defluffisizer_work/{source_stem}/`
+
+Use it for extracted text, editable JSON, lint outputs, and before or after comparisons. Those are scratch files, not the deliverable.
+
+The final user facing output does not go in the work directory. Write it with `scripts/document_text_io.py apply SOURCE REWRITTEN [--output-dir DIR]`, and let the script name it. With no `--output-dir`, that lands the file next to `SOURCE` as `{source_stem}_defluffed{output_ext}` automatically; pass `--output-dir` only when `OUTPUT_DIR` differs from the source directory. Only pass an explicit `--output PATH` when the user names an exact filename, not just a directory.
+
+## Format routing
+
+Before choosing tools, read [knowledge/format_capabilities.md](knowledge/format_capabilities.md).
+
+Use:
+
+- `scripts/document_text_io.py` for `.txt`, `.md`, `.doc`, `.docx`, `.odt`, `.rtf`, `.html`, `.pdf`, and `.pptx`
+- `scripts/pptx_rewrite.py` directly only when you already have a prepared PowerPoint replacement JSON
+- `scripts/defluff_lint.py` after meaningful rewrites
+
+## Execute pipeline
+
+### Stage 1 - Intake and preservation inventory
+
+Read and follow: [pipeline/01_intake_and_scope.md](pipeline/01_intake_and_scope.md)
+
+### Stage 2 - Extraction and structure mapping
+
+Read and follow: [pipeline/02_extract_and_map.md](pipeline/02_extract_and_map.md)
+
+Before or during this stage, also read:
+
+- [guardrails/fact_preservation.md](guardrails/fact_preservation.md)
+- [guardrails/format_safety.md](guardrails/format_safety.md)
+
+### Stage 3 - Rewrite and human signal pass
+
+Read and follow: [pipeline/03_rewrite_and_defluff.md](pipeline/03_rewrite_and_defluff.md)
+
+Before this stage, also read:
+
+- [guardrails/anti_humanizer_theater.md](guardrails/anti_humanizer_theater.md)
+- [references/ai_slop_signals.md](references/ai_slop_signals.md)
+- [references/human_signal_playbook.md](references/human_signal_playbook.md)
+
+If the source is a slide deck, spreadsheet, or locked file, also read:
+
+- [references/format_playbook.md](references/format_playbook.md)
+
+### Stage 4 - Apply and validate
+
+Read and follow: [pipeline/04_apply_and_validate.md](pipeline/04_apply_and_validate.md)
+
+Before finalizing, also read:
+
+- [references/evaluation_playbook.md](references/evaluation_playbook.md)
+
+## What to optimize for
+
+- Keep the meaning.
+- Cut the padding.
+- Put the point early.
+- Preserve numbers, dates, names, caveats, and constraints.
+- Prefer direct, declarative sentences with a visible subject and verb.
+- Preserve real stakes, tension, and asymmetry when the source contains them.
+- Return the source in its own format, `.pptx` to `.pptx`, `.docx` to `.docx`, `.pdf` to `.pdf`, unless the user asks for a different one. Alignment, layout, and structure should look like the source with new text in it, not a redesign and not a downgrade to a different format.
+
+## Banned patterns
+
+Avoid in rewritten prose unless preserved inside a quote or fixed technical term. Read [references/ai_slop_signals.md](references/ai_slop_signals.md) before a substantial rewrite for the full reasoning behind these; the fast version:
+
+- em dashes glued tight to a word with no space (`word—word`). Almost always eliminate by rephrasing: split into two sentences, or use a comma, colon, or period. In the rare case an em dash is genuinely the clearest option, space it normally (`word — word`). Never keep the tight, glued form.
+- false contrast used for emphasis, in any surface form: `not X, but Y`, `it's not X, it's Y`, `X, not just Y`, or the same move split across two sentences (`This is not X. It is Y.`). If the positive half already stands on its own, delete the negative half instead of rephrasing it.
+- defensive contrast against a criticism nobody raised (`a real PDF, not just a downgrade`, `no compromises`, `not a shortcut`). State the capability plainly. Do not compare it to a weaker alternative to make it sound better.
+- punchline fragments: a full sentence, then a short fragment right after it riding that sentence's momentum for effect (`Strips the fluff. Keeps the facts.`). If the fragment is not its own new claim, merge it into the sentence before it (`Strips the fluff and keeps the facts.`). Ordinary short sentences and real variation in sentence length are fine and encouraged; this is specifically the fragment-as-mic-drop tic, not sentence-length variation generally.
+- ordinary hyphenated phrasing when a plain alternative works
+- throat clearing and formulaic openers (`in today's...`, `it's worth noting...`, `when it comes to...`)
+- abstraction piles
+- stacked synonyms
+- rule of three padding: three adjectives or clauses stacked for rhythm instead of meaning (`real, honest, and direct`)
+- empty amplifiers that add emphasis without adding information (`truly`, `genuinely`, `really`, `very`, `simply`)
+- unearned superlatives (`revolutionary`, `game changing`, `cutting edge`, `best in class`, `world class`)
+- generic uplift the source did not earn
+
+## Final output
+
+Print a short summary:
+
+`defluffisizer complete for: {source_name}
+Mode: {MODE} | Aggression: {AGGRESSION}
+Output: {output_path_printed_by_apply, or inline result for pasted text}
+Format preserved: {yes_or_best_effort}
+Lint summary: {key result or skipped}
+`

package/skills/defluffisizer/bin/defluffisizer.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageRoot = path.resolve(__dirname, "..");
+const repoPackagePath = path.resolve(packageRoot, "..", "..", "package.json");
+const promptPath = path.join(packageRoot, "prompts", "append_system_prompt.txt");
+const scriptsRoot = path.join(packageRoot, "scripts");
+const defaultTarget = path.join(os.homedir(), ".codex", "skills");
+const skillEntries = [
+  "SKILL.md",
+  "README.md",
+  "agents",
+  "guardrails",
+  "harnesses",
+  "knowledge",
+  "pipeline",
+  "prompts",
+  "references",
+  "scripts",
+  "worked",
+];
+function usage() {
+  console.log(`defluffisizer
+
+Usage:
+  defluffisizer install [--target PATH] [--force]
+  defluffisizer prompt
+  defluffisizer probe <file>
+  defluffisizer extract <file> --out <path>
+  defluffisizer apply <source> <rewritten> --output <path>
+  defluffisizer lint [--before BEFORE --after AFTER] [file]
+  defluffisizer version
+  defluffisizer where
+`);
+}
+
+function copyRecursive(source, destination) {
+  const stat = fs.statSync(source);
+  if (stat.isDirectory()) {
+    fs.mkdirSync(destination, { recursive: true });
+    for (const entry of fs.readdirSync(source)) {
+      copyRecursive(path.join(source, entry), path.join(destination, entry));
+    }
+    return;
+  }
+  fs.mkdirSync(path.dirname(destination), { recursive: true });
+  fs.copyFileSync(source, destination);
+}
+
+function getFlagValue(args, flag) {
+  const index = args.indexOf(flag);
+  if (index >= 0 && args[index + 1]) {
+    return args[index + 1];
+  }
+  return null;
+}
+
+function getTargetRoot(args, fallback) {
+  const target = getFlagValue(args, "--target");
+  return target ? path.resolve(target) : fallback;
+}
+
+function shouldForce(args) {
+  return args.includes("--force");
+}
+
+function copyEntryList(sourceRoot, destinationRoot, entries) {
+  fs.mkdirSync(destinationRoot, { recursive: true });
+  for (const entry of entries) {
+    const source = path.join(sourceRoot, entry);
+    if (fs.existsSync(source)) {
+      copyRecursive(source, path.join(destinationRoot, entry));
+    }
+  }
+}
+
+function install(args) {
+  const force = shouldForce(args);
+  const targetRoot = getTargetRoot(args, defaultTarget);
+  const destination = path.join(targetRoot, "defluffisizer");
+
+  if (fs.existsSync(destination) && !force) {
+    console.error(`Destination exists: ${destination}`);
+    console.error("Re run with --force to overwrite.");
+    process.exit(1);
+  }
+
+  if (fs.existsSync(destination) && force) {
+    fs.rmSync(destination, { recursive: true, force: true });
+  }
+
+  copyEntryList(packageRoot, destination, skillEntries);
+
+  console.log(`Installed defluffisizer to ${destination}`);
+}
+
+function printPrompt() {
+  process.stdout.write(fs.readFileSync(promptPath, "utf8"));
+}
+
+function printWhere() {
+  console.log(packageRoot);
+}
+
+function printVersion() {
+  const pkg = JSON.parse(fs.readFileSync(repoPackagePath, "utf8"));
+  console.log(pkg.version);
+}
+
+function resolvePython() {
+  const candidates = [process.env.PYTHON, "python3", "python"].filter(Boolean);
+  for (const candidate of candidates) {
+    const probe = spawnSync(candidate, ["--version"], { stdio: "ignore" });
+    if (probe.status === 0) {
+      return candidate;
+    }
+  }
+  console.error("Could not resolve a Python executable.");
+  process.exit(1);
+}
+
+function runPython(scriptName, args) {
+  const python = resolvePython();
+  const scriptPath = path.join(scriptsRoot, scriptName);
+  const result = spawnSync(python, [scriptPath, ...args], { stdio: "inherit" });
+  if (result.error) {
+    console.error(result.error.message);
+    process.exit(1);
+  }
+  process.exit(result.status ?? 1);
+}
+
+const [, , command, ...args] = process.argv;
+
+if (!command || command === "--help" || command === "-h") {
+  usage();
+  process.exit(0);
+}
+
+if (command === "--version" || command === "-v" || command === "version") {
+  printVersion();
+  process.exit(0);
+}
+
+if (command === "install") {
+  install(args);
+} else if (command === "prompt") {
+  printPrompt();
+} else if (command === "probe") {
+  runPython("document_text_io.py", ["probe", ...args]);
+} else if (command === "extract") {
+  runPython("document_text_io.py", ["extract", ...args]);
+} else if (command === "apply") {
+  runPython("document_text_io.py", ["apply", ...args]);
+} else if (command === "lint") {
+  runPython("defluff_lint.py", args);
+} else if (command === "where") {
+  printWhere();
+} else {
+  usage();
+  process.exit(1);
+}

package/skills/defluffisizer/guardrails/anti_humanizer_theater.md

@@ -0,0 +1,20 @@
+# Anti Humanizer Theater
+
+The goal is better writing, not detector evasion theater.
+
+## Do not do these things
+
+- add slang to sound more human
+- add typos or broken grammar
+- inject personal anecdotes that were not in the source
+- flatten important caveats because they sound too formal
+- swap precise technical terms for vague casual language
+
+## Better approach
+
+- cut redundancy
+- cut abstraction
+- name the actor
+- name the action
+- name the consequence
+- keep the real friction