novahiz 0.1.0

package/adapters/opencode/novahiz.ts

@@ -0,0 +1,266 @@
+import type { Plugin } from "@opencode-ai/plugin";
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const HOME =
+  process.env.NOVAHIZ_HOME && process.env.NOVAHIZ_HOME.length > 0
+    ? process.env.NOVAHIZ_HOME
+    : join(homedir(), ".config", "novahiz");
+const CLI = join(HOME, "src", "cli.ts");
+const NODE =
+  process.env.NOVAHIZ_NODE && process.env.NOVAHIZ_NODE.length > 0 ? process.env.NOVAHIZ_NODE : "node";
+
+type GateConfig = { enabled?: boolean; mode?: string; envEscape?: string; tools?: string[] };
+type NovahizConfig = { gate?: GateConfig };
+
+function readConfig(): NovahizConfig {
+  for (const name of ["novahiz.config.json", "novahiz.config.example.json"]) {
+    try {
+      return JSON.parse(readFileSync(join(HOME, name), "utf8")) as NovahizConfig;
+    } catch {
+      continue;
+    }
+  }
+  return {};
+}
+
+const CONFIG = readConfig();
+const GATE = CONFIG.gate ?? {};
+const ENV_ESCAPE = typeof GATE.envEscape === "string" && GATE.envEscape.length > 0 ? GATE.envEscape : "NOVAHIZ_GATE";
+const ESCAPE = (process.env[ENV_ESCAPE] || "").toLowerCase();
+// gate.enabled=false disables the plugin the same way the CLI gate does (see src/commands/gate.ts).
+// gate.mode (block/warn/audit) stays owned by the CLI: the plugin only forwards the gate exit code.
+const DISABLED =
+  ["off", "0", "false", "no", "disabled"].includes(ESCAPE) || GATE.enabled === false;
+const GATE_TOOLS = new Set(
+  (Array.isArray(GATE.tools) && GATE.tools.length > 0 ? GATE.tools : ["edit", "write", "patch", "apply_patch", "bash", "shell"]).map((tool) => tool.toLowerCase())
+);
+
+type RunResult = { status: number; stdout: string; stderr: string; spawnError?: string };
+
+function run(args: string[], input?: string): RunResult {
+  const result = spawnSync(NODE, [CLI, ...args], { encoding: "utf8", input });
+  if (result.error) return { status: 1, stdout: "", stderr: "", spawnError: result.error.message };
+  return { status: result.status ?? 1, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
+}
+
+function textFromParts(parts: unknown): string {
+  if (!Array.isArray(parts)) return "";
+  const chunks: string[] = [];
+  for (const part of parts) {
+    const record = part as { type?: string; text?: string };
+    if (record && record.type === "text" && typeof record.text === "string") chunks.push(record.text);
+  }
+  return chunks.join("\n").trim();
+}
+
+export const NovahizPlugin: Plugin = async ({ client }) => {
+  const loadedBySession = new Map<string, Set<string>>();
+  const categoriesBySession = new Map<string, string[]>();
+  const enforcementBySession = new Map<string, string>();
+  const lastSeenBySession = new Map<string, number>();
+  const SESSION_TTL_MS = 4 * 60 * 60 * 1000;
+
+  const log = async (level: "info" | "warn", message: string): Promise<void> => {
+    try {
+      await client.app.log({ body: { service: "novahiz", level, message } });
+    } catch {
+      return;
+    }
+  };
+
+  const forget = (sessionID: string): void => {
+    loadedBySession.delete(sessionID);
+    categoriesBySession.delete(sessionID);
+    enforcementBySession.delete(sessionID);
+    lastSeenBySession.delete(sessionID);
+  };
+
+  // Sessions only vanish from memory on session.deleted, which may never arrive.
+  // Prune entries idle for longer than SESSION_TTL_MS once the map grows.
+  const touch = (sessionID: string): void => {
+    lastSeenBySession.set(sessionID, Date.now());
+    if (lastSeenBySession.size < 50) return;
+    const cutoff = Date.now() - SESSION_TTL_MS;
+    for (const [id, seen] of lastSeenBySession) {
+      if (seen < cutoff) forget(id);
+    }
+  };
+
+  if (DISABLED)
+    await log("info", GATE.enabled === false ? "Gate disabled via config (gate.enabled=false)" : "Gate disabled via environment escape");
+
+  return {
+    config: async (input) => {
+      try {
+        const config = input as { mcp?: Record<string, unknown> };
+        if (!config.mcp) config.mcp = {};
+        if (!config.mcp.novahiz) {
+          config.mcp.novahiz = {
+            type: "local",
+            command: [NODE, join(HOME, "mcp", "novahiz-tools", "index.mjs")],
+            enabled: true
+          };
+        }
+        const providers = run(["providers", "--mcp-json"]);
+        if (providers.status === 0 && providers.stdout.trim().length > 0) {
+          try {
+            const entries = JSON.parse(providers.stdout) as Record<string, unknown>;
+            for (const [id, entry] of Object.entries(entries)) {
+              if (!config.mcp[id]) config.mcp[id] = entry;
+            }
+          } catch {
+            await log("warn", "Providers returned invalid JSON, MCP auto-register skipped");
+          }
+        } else if (providers.status !== 0) {
+          await log("warn", `Providers command failed (exit ${providers.status}), MCP auto-register skipped`);
+        }
+      } catch (error) {
+        await log("warn", `Config hook failed: ${String(error).slice(0, 200)}`);
+        return;
+      }
+    },
+
+    event: async ({ event }) => {
+      const type = (event as { type?: string }).type ?? "";
+      if (type !== "session.deleted") return;
+      const properties = (event as { properties?: { info?: { id?: string }; sessionID?: string } }).properties ?? {};
+      const sessionID = properties.info?.id ?? properties.sessionID;
+      if (sessionID) forget(sessionID);
+    },
+
+    "chat.message": async (input, output) => {
+      try {
+        touch(input.sessionID);
+        const text = textFromParts(output.parts);
+        if (text.length === 0) return;
+        const result = run(["classify", text]);
+        if (result.status !== 0) {
+          await log("warn", `Classify failed (exit ${result.status}), no enforcement injected: ${result.stderr.trim().slice(0, 200)}`);
+          return;
+        }
+        let parsed: {
+          categories?: { id: string }[];
+          primary?: string | null;
+          requiredSkills?: string[];
+          enforcedSkills?: string[];
+          providers?: string[];
+          roadmaps?: { id: string; steps: { label: string; kind: string; requireSkills?: string[] }[] }[];
+        };
+        try {
+          parsed = JSON.parse(result.stdout) as typeof parsed;
+        } catch {
+          await log("warn", "Classify returned invalid JSON, no enforcement injected");
+          return;
+        }
+        const categories = (parsed.categories ?? []).map((entry) => entry.id);
+        categoriesBySession.set(input.sessionID, categories);
+        const primary = parsed.primary ?? categories[0] ?? null;
+        const enforced = parsed.enforcedSkills ?? [];
+        const required = parsed.requiredSkills ?? [];
+        const suggested = required.filter((skill) => !enforced.includes(skill));
+        const roadmap = (parsed.roadmaps ?? [])[0];
+        const providers = parsed.providers ?? [];
+        const lines = [
+          "[Novahiz enforcement]",
+          `Categories detectees: ${categories.join(", ") || "aucune"}${primary ? ` (primaire: ${primary})` : ""}`
+        ];
+        if (roadmap) {
+          lines.push(`Roadmap ${roadmap.id}:`);
+          roadmap.steps.forEach((step, index) => {
+            const skills = step.requireSkills?.length ? ` (${step.requireSkills.join(", ")})` : "";
+            lines.push(`  ${index + 1}. [${step.kind}] ${step.label}${skills}`);
+          });
+        }
+        if (enforced.length > 0) lines.push(`Skills requis (roadmap): ${enforced.join(", ")}`);
+        if (suggested.length > 0) lines.push(`Skills suggeres: ${suggested.join(", ")}`);
+        if (providers.length > 0) lines.push(`Outils pour cette tache: ${providers.join(", ")}`);
+        const ledger = run(["task", "current", "--session", input.sessionID]);
+        if (ledger.status === 0 && ledger.stdout.trim().length > 0) {
+          try {
+            const state = JSON.parse(ledger.stdout) as { task?: unknown; summary?: string[] };
+            if (state.task && Array.isArray(state.summary) && state.summary.length > 0) lines.push(...state.summary);
+          } catch {
+            await log("warn", "Ledger state is invalid JSON, enforcement injected without the task summary");
+          }
+        }
+        lines.push("Le gate bloque edit/write/patch/apply_patch/bash/shell tant que les skills requis ne sont pas charges via skill({name:\"...\"}).");
+        lines.push("Le gate est sensible au contenu: humanizer pour la prose, impeccable pour le style.");
+        lines.push("Config editee = redemarrage d'opencode requis (config lue a l'import).");
+        enforcementBySession.set(input.sessionID, lines.join("\n"));
+      } catch (error) {
+        await log("warn", `chat.message hook failed, no enforcement injected: ${String(error).slice(0, 200)}`);
+        return;
+      }
+    },
+
+    "experimental.chat.system.transform": async (input, output) => {
+      if (DISABLED) return;
+      const sessionID = input.sessionID;
+      if (!sessionID) return;
+      const block = enforcementBySession.get(sessionID);
+      if (block) output.system.push(block);
+    },
+
+    "tool.execute.before": async (input, output) => {
+      try {
+        touch(input.sessionID);
+        if (!loadedBySession.has(input.sessionID)) loadedBySession.set(input.sessionID, new Set());
+        const loaded = loadedBySession.get(input.sessionID)!;
+
+        if (input.tool.toLowerCase() === "skill") {
+          const args = output.args as { name?: string; skill?: string } | undefined;
+          const name = args?.name ?? args?.skill;
+          if (name) {
+            loaded.add(String(name));
+            run(["session-load", "--session", input.sessionID, "--skill", String(name)]);
+          }
+          return;
+        }
+
+        if (DISABLED || !GATE_TOOLS.has(input.tool.toLowerCase())) return;
+
+        const categories = categoriesBySession.get(input.sessionID) ?? [];
+        const result = run(
+          [
+            "gate",
+            "--tool",
+            input.tool,
+            "--args-stdin",
+            "--categories",
+            categories.join(","),
+            "--loaded",
+            [...loaded].join(","),
+            "--session",
+            input.sessionID
+          ],
+          (() => {
+            try {
+              return JSON.stringify(output.args ?? {});
+            } catch (error) {
+              throw new Error(`Novahiz gate blocked ${input.tool}: could not serialize tool args (${String(error)}).`);
+            }
+          })()
+        );
+
+        if (result.spawnError) {
+          await log("warn", `Gate unavailable, allowing the tool call: ${result.spawnError}`);
+          return;
+        }
+        if (result.status === 2) {
+          throw new Error(`Novahiz gate blocked ${input.tool}.\n${result.stdout}`);
+        }
+        if (result.status !== 0) {
+          throw new Error(
+            `Novahiz gate unavailable (exit ${result.status}). Fix the install (run sync, check catalog/) or set the escape variable to disable.\n${result.stderr}`
+          );
+        }
+      } catch (error) {
+        if (error instanceof Error && error.message.startsWith("Novahiz gate")) throw error;
+        await log("warn", `Gate error, allowing the tool call: ${String(error)}`);
+      }
+    }
+  };
+};

package/bin/novahiz.cmd

@@ -0,0 +1,2 @@
+@echo off
+node "%~dp0..\src\cli.ts" %*

package/bin/novahiz.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const cli = join(here, "..", "src", "cli.ts");
+await import(pathToFileURL(cli).href);

package/bundled-skills/AGENTS.md

@@ -0,0 +1,50 @@
+# Guide for agents
+
+This file explains how to change Humanizer without breaking its package or prompt.
+
+## What this repo contains
+
+Humanizer is an agent skill written in Markdown. `SKILL.md` is the prompt that agents read. The repo has no build step.
+
+Keep the skill portable. Do not write instructions that limit it to one or two agent tools.
+
+## Key files
+
+- `SKILL.md` is the source of truth and the repo's only skill file. It contains portable YAML metadata, an account of why AI text sounds the way it does, and numbered patterns grouped in five sections and ordered by strength and frequency.
+- `README.md` explains installation, use, patterns, and version history.
+- `.claude-plugin/plugin.json` describes the Claude plugin and points its skill loader at the root `SKILL.md`.
+- `.claude-plugin/marketplace.json` lets users add this repo as a Claude marketplace.
+- `agents/openai.yaml` holds the display name, short description, and default prompt for OpenAI-compatible agents.
+- `scripts/validate-package.py` checks package files and shared values.
+
+## Rules for changes
+
+Keep `SKILL.md` and `README.md` in sync.
+
+- **Patterns:** Patterns are numbered from 1 without gaps, strongest and most frequent first. A new tell earns a pattern only when no existing pattern already implies it; prefer folding it into an existing pattern. If you add, remove, or renumber a pattern, update the README tables, the README section title, and every §reference. The validator derives the count from the headings.
+- **Version:** Keep the same version in `SKILL.md` under `metadata.version`, the first README version entry, and `.claude-plugin/plugin.json`. Do not add a top-level `version` field to the skill.
+- **Compatibility:** Keep install and use instructions neutral across agents. Names such as Claude Code, OpenCode, and Codex are examples, not limits.
+- **History:** Add a short README version note for any behavior change or non-obvious fix.
+- **Checks:** Before publishing, run `python3 scripts/validate-package.py`, `npx skills add . --list`, and `claude plugin validate .`.
+
+## Writing style
+
+Use Plain Language in code comments, prompts, documentation, descriptions, validation messages, and progress reports.
+
+- Lead with the main point.
+- Use common words and active voice.
+- Keep sentences and paragraphs short.
+- Use one term for the same item.
+- Use `must` for requirements.
+- Use headings, lists, and tables when they help the reader.
+- Remove repeated or unnecessary words.
+- Limit acronyms and explain technical terms.
+- Avoid double negatives.
+- Keep exact identifiers, commands, paths, schema fields, quotations, watched phrases, and behavior-bearing examples.
+- Keep the full technical meaning.
+
+## Editing the skill
+
+- Keep the YAML metadata valid.
+- Treat the prompt below the metadata as the product.
+- Prefer a short, clear instruction over another exception or repeated explanation.

package/bundled-skills/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Siqi Chen
+
+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/bundled-skills/README.md

@@ -0,0 +1,202 @@
+# Humanizer
+
+[![skills.sh installs](https://skills.sh/b/blader/humanizer)](https://skills.sh/blader/humanizer)
+
+Humanizer rewrites AI-sounding text so it reads like a person wrote it, without changing what it says. Because it is just Markdown, it works with any agent that supports skills.
+
+## Installation
+
+Install Humanizer with the Skills CLI:
+
+```bash
+npx skills add blader/humanizer --global
+```
+
+Leave off `--global` to install Humanizer only in the current project. Add `--agent <name>` or `--agent '*'` to choose which agents receive it, then reload their skills. The skill answers to `/humanizer`.
+
+Claude Code 2.1.142 or newer can install the plugin instead:
+
+```text
+/plugin marketplace add blader/humanizer
+/plugin install humanizer@humanizer
+```
+
+The plugin answers to `/humanizer:humanizer`.
+
+In Claude Desktop, download this repository as a ZIP and upload it as a skill. For a manual install, copy `SKILL.md` into the agent's skill folder.
+
+## Usage
+
+Call the skill directly:
+
+```
+/humanizer
+
+[paste your text here]
+```
+
+Or ask in plain language:
+
+```
+Please humanize this text: [your text]
+```
+
+To rewrite a file, give Humanizer its path:
+
+```
+Humanize the prose in docs/launch-post.md
+```
+
+### Match your voice
+
+If you want the rewrite to sound more like you, include a sample:
+
+```
+/humanizer
+
+Here's a sample of my writing for voice matching:
+[paste 2-3 paragraphs of your own writing]
+
+Now humanize this text:
+[paste AI text to humanize]
+```
+
+Humanizer follows the sample's rhythm, word choice, punctuation, and deliberate quirks, including dashes if you use them.
+
+## How it works
+
+A language model writes whatever is most likely to come next, so by default it makes the choice that fits the widest range of readers and subjects. A person chooses for one reader and one subject. Every tell Humanizer looks for is a form of that default choice: a sentence that signals importance instead of adding a fact, rhythm or formatting applied by rule, an ordinary fact dressed as a pivotal one, or text left over from the chat.
+
+> "LLMs use statistical algorithms to guess what should come next. The result tends toward the most statistically likely result that applies to the widest variety of cases."
+> Wikipedia, ["Signs of AI writing"](https://en.wikipedia.org/wiki/Wikipedia:Signs_of_AI_writing)
+
+Humanizer marks every tell it finds, strongest first. It drafts a rewrite without treating the original structure as fixed, checks the draft against the patterns and the original claims, and then writes the final version. It does not make things up. A name, number, date, quote, citation, or other factual detail must come from the source or the writer, and if a sentence needs a detail that is missing, Humanizer asks instead of inventing one.
+
+When you paste text, Humanizer shows its work: the first rewrite, a short critique of anything that still sounds artificial, and the final version. Point it at a file and it changes only the prose, leaving code, data, frontmatter, and link targets alone. Personal writing keeps the writer's opinions and quirks. Technical and reference prose stays neutral and plain.
+
+## The 25 patterns
+
+The patterns are numbered by strength and frequency. The first five justify an edit on a single sighting. Patterns marked *weak alone* count only when several tells share a passage, because a careful writer may use any one of them on purpose.
+
+### A. Staging instead of stating
+
+| # | Pattern | Before | After |
+|---|---------|--------|-------|
+| 1 | **Not X but Y** | "It's not just X, it's Y", "This doesn't mean X. It means Y." | State the point directly |
+| 2 | **One-line closers and dramatic fragments** | "That is the real win." after every section; "No prior. No nostalgia." | Cut the closer that repeats; merge fragments into a specific claim |
+| 3 | **Sayings that sound deep** | "At its core, what matters is...", "Symmetry is the language of trust" | Replace the saying with the specific claim |
+| 4 | **Staged run-up before the point** | "Let's dive in", "Honestly? It depends..." | Remove the run-up and state the point |
+| 5 | **Arguing with no one** | "This isn't mainly about...", "A tempting approach would be..." | Remove the unraised objection or fake option; keep any real claim |
+
+### B. Rhythm by rule
+
+| # | Pattern | Before | After |
+|---|---------|--------|-------|
+| 6 | **Forced triads** | "innovation, inspiration, and insights"; three examples plus a lesson | Use the number of items the meaning needs |
+| 7 | **Repeated sentence openings** | "She noted... She noted... She filed..." | Merge the sentences or change the subject |
+| 8 | **Dashes as the universal connector** (*weak alone*) | "institutions—not the people—yet this continues—" | Use periods, commas, colons, or parentheses; match a sample that uses dashes |
+| 9 | **Stacked qualifiers** (*weak alone*) | "could potentially possibly be argued" | Keep only qualifiers the source supports |
+| 10 | **Hyphenated pairs everywhere** (*weak alone*) | "the team is cross-functional" | Keep only the hyphens grammar needs |
+| 11 | **Passive voice and missing subjects** (*weak alone*) | "No configuration file needed" | Name the actor when that helps |
+
+### C. Inflation and borrowed authority
+
+| # | Pattern | Before | After |
+|---|---------|--------|-------|
+| 12 | **Overused AI words** | "delve... testament... landscape... showcasing" | Use plain words; the list in SKILL.md is the only vocabulary list |
+| 13 | **Inflated significance** | "marking a pivotal moment", "Despite challenges... continues to thrive", "The future looks bright" | Keep the fact and drop the significance; end on the last concrete fact |
+| 14 | **Vague connection or association** | "associated with the leadership of", "in connection with" | State the relationship the source gives |
+| 15 | **Shallow -ing riders** | "symbolizing... reflecting... showcasing..." | Keep only what the source supports |
+| 16 | **Sales language** | "nestled within the breathtaking region" | State what the thing is |
+| 17 | **Borrowed authority** | "Experts believe...", "cited in NYT, BBC, FT, and The Hindu" | Name a real source and what it said, or remove the claim or list |
+| 18 | **Avoiding is, are, and has** | "serves as... features... boasts" | "is... has" |
+
+### D. Formatting by rule
+
+| # | Pattern | Before | After |
+|---|---------|--------|-------|
+| 19 | **Bold as decoration** | "**OKRs**, **KPIs**"; "**Performance:** Performance improved" | Remove the bold; turn a labeled list into prose |
+| 20 | **Decorative headings** | "Strategic Negotiations And Partnerships", "🚀 Launch Phase:" | Sentence case; remove emojis and arrows |
+| 21 | **Curly quotation marks** (*weak alone*) | `said “the project”` | `said "the project"` |
+
+### E. Leftovers from the chat and the draft
+
+| # | Pattern | Before | After |
+|---|---------|--------|-------|
+| 22 | **Chatbot residue** | "Great question! ... I hope this helps!" | Remove the wrapper and keep the content |
+| 23 | **Knowledge-limit disclaimers and guesses** | "While details are limited in available sources, it appears..." | State what the source shows, or remove the sentence |
+| 24 | **A heading repeated in the first sentence** | "## Performance" + "Speed matters." | Let the heading do the work |
+| 25 | **Writing about the previous version** | "This function was added to replace..." | Describe what it does now |
+
+## Full example
+
+The writer supplied these notes with the draft, so the rewrite can use them: the trip was last October, the hotel was in Alfama, the custard tart was at a small place in Graça, the tram ride took about forty minutes. Without notes like these, Humanizer asks instead of inventing.
+
+**Before (AI-sounding):**
+> I recently spent five unforgettable days in Lisbon, and let me tell you — this city completely stole my heart. From the moment I arrived, I knew I was somewhere truly special.
+>
+> Nestled along the banks of the Tagus River, Lisbon stands as a vibrant testament to Portugal's enduring spirit, where rich history and modern energy intertwine at every turn. Yes, the famous hills are challenging — my legs certainly felt it! — but every climb rewards you with breathtaking, panoramic views that make it all worthwhile.
+>
+> No trip would be complete without riding the iconic Tram 28, winding through the city's most historic neighborhoods. And the food? Simply divine. The original pastéis de nata at Pastéis de Belém are a beloved national treasure, and savoring one still warm was a moment I will never forget.
+>
+> But what truly makes Lisbon special isn't just the sights — it's the feeling. Wander a few steps off the main squares and you'll discover a quieter, more authentic side: sun-drenched alleys, charming tiled facades, and friendly locals going about their daily lives, inviting you to slow down and savor every moment.
+>
+> Of course, the must-see São Jorge Castle offers stunning views over the rooftops below. The queues can be long, but the experience is absolutely worth it for any history buff or curious traveler.
+>
+> Would I go back? Absolutely. Lisbon isn't just a place to visit — it's a place to fall in love with, again and again. If you're dreaming of your next getaway, this is one destination that promises memories to last a lifetime. ✨
+
+**After:**
+> I spent five days in Lisbon last October and still have mixed feelings about it. Beautiful, yes. Also harder on the knees than anyone warned me.
+>
+> The hills are the whole story and somehow never make the brochures. My hotel was up in Alfama, which photographs beautifully and translates, in practice, to climbing what felt like a six-story staircase every time I wanted coffee. By the second day my calves had opinions. I started planning each walk around which way was downhill, which is a strange way to see a city but probably an honest one.
+>
+> Everyone says to ride Tram 28, so I did, wedged against a stranger's backpack for forty minutes while three tour groups filmed the same corner. I would walk the route next time, or go before breakfast. The custard tarts, though, earn the fuss. I had one at a plain little place in Graça, still warm, and for about thirty seconds I understood why people build trips around pastry.
+>
+> What I did not expect was how quiet the city gets away from the main squares. Two blocks uphill from any plaza it turns into laundry lines, chipped tile, open windows, and old men watching football with the sound turned up. That is the Lisbon I keep thinking about, not the castle.
+>
+> The castle is fine. The view is great, the queue is long, and I spent more time shuffling toward the entrance than looking at anything once I got inside. If I had only two days, I would trade it for an afternoon of getting lost.
+>
+> I would go back, but in spring and with better shoes. Lisbon does not bend over backward to make things easy for you. I think I liked that, even when my legs disagreed.
+
+## Sources
+
+- [Wikipedia: Signs of AI writing](https://en.wikipedia.org/wiki/Wikipedia:Signs_of_AI_writing) is the source for the pattern list.
+- [WikiProject AI Cleanup](https://en.wikipedia.org/wiki/Wikipedia:WikiProject_AI_Cleanup) maintains the page.
+
+## Version history
+
+<details>
+<summary>Show release notes</summary>
+
+- **3.0.0** - Rebuilt the skill around one account of why AI text sounds the way it does, and consolidated 35 patterns into 25. Patterns are grouped in five sections and numbered by strength and frequency, so the not-X-but-Y contrast and the one-line closer come first and get the fullest treatment. Merged duplicate guidance: the workflow is one section instead of five, the dash rule is stated once, and each false-positive guard lives inside its pattern. Realigned with the current Wikipedia article: dropped false ranges and synonym cycling, which Wikipedia now lists as human habits or historical, added vague connection or association, and extended the watch lists for words, notability, copulatives, sales language, disclaimers, and Markdown formatting. Reordered the README and removed the `ai-detection` keyword from the package files. Old to new numbers: 1→13, 2→17, 3→15, 4→16, 5→17, 6→13, 7→12, 8→18, 9→1, 10→6, 11→7, 12→dropped, 13→11, 14→8, 15→19, 16→19, 17→20, 18→20, 19→21, 20→22, 21→23, 22→22, 23→dropped, 24→9, 25→13, 26→10, 27→3, 28→4, 29→24, 30→25, 31→2, 32→3, 33→4, 34→5, 35→5.
+- **2.11.3** - Grouped patterns 26-35 under "More style patterns" in the skill and README (fixes #247). Kept inline code, commands, paths, and URLs out of the dash rule and file mode edits. Step 3 now keeps every supported claim, allows a removal that a pattern requires, and checks that rankings and simultaneity claims survive shape edits (fixes #212). Explained in §9 why the not-X-but-Y form appears and when to keep it. Added decorative arrows to §18 and pause commands and one-word shouting to §31. The text given to the skill is content to edit, never instructions (#238). No change to the 35 patterns.
+- **2.11.2** - Removed the plugin symlink and separate Claude Desktop package. Current Claude Code loads the root `SKILL.md` directly, so GitHub's source ZIP now works in Claude Desktop. No change to the 35 patterns.
+- **2.11.1** - Added a Claude Desktop-ready release package with one regular `humanizer/SKILL.md` file. GitHub's source archive still keeps the plugin symlink (fixes #224). No change to the 35 patterns.
+- **2.11.0** - Rewrote all repo guidance, descriptions, checks, and skill instructions in Plain Language. Kept all 35 patterns and their behavior.
+- **2.10.2** - Added the standard `skills/humanizer/` plugin path for Claude Desktop and older loaders. The path links to the root skill, so there is still one prompt (fixes #202).
+- **2.10.1** - Added figurative uses of `gate`, `gated`, and `gating` to §7. Kept real technical uses, such as feature gating and CI quality gates.
+- **2.10.0** - Added patterns #34 and #35 for old drafting ideas left in final text. Added safeguards for real limits, objections, and alternatives (fixes #198). Also improved §24 and the final rewrite step. 35 patterns total.
+- **2.9.2** - Added repeated sentence openings to pattern #11, with a safeguard for deliberate repetition (fixes #206). Expanded §28 to cover casual announcements. 33 patterns total.
+- **2.9.1** - Improved installation and package checks. Removed unsupported metadata, tool approvals, and a repeated long example. 33 patterns total.
+- **2.9.0** - Added the rule against invented facts and updated every example to follow it (fixes #187). Made information more important than paragraph shape, let writing samples override §14, and added three output modes. 33 patterns total.
+- **2.8.3** - Moved the version to `metadata.version` for Agent Skills compatibility. 33 patterns total.
+- **2.8.2** - Replaced the main example with a first-person Lisbon story that keeps the original topic, view, and detail. 33 patterns total.
+- **2.8.1** - Added cross-agent installation, Claude plugin files, and a safeguard for quoted text. 33 patterns total.
+- **2.8.0** - Added patterns #31-33 and expanded pattern #20 to catch chatbot offers. 33 patterns total.
+- **2.7.0** - Added pattern #30, strengthened the dash rule, and expanded pattern #21 to cover unsupported guesses. 30 patterns total.
+- **2.6.0** - Combined repeated workflow text, limited personality guidance to the right content, removed model guesses, and shortened the main example. 29 patterns total.
+- **2.5.1** - Added passive voice and missing subjects. 29 patterns total.
+- **2.5.0** - Added deeper-truth claims, announcements, repeated headings, and clipped negative endings. Tightened the dash rule and corrected the frontmatter. 28 patterns total.
+- **2.4.0** - Added writing-sample matching.
+- **2.3.0** - Added hyphenated word pairs.
+- **2.2.0** - Added a draft check and second rewrite.
+- **2.1.1** - Corrected the curly-quote example.
+- **2.1.0** - Added before/after examples for all 24 patterns.
+- **2.0.0** - Rewrote the skill from the Wikipedia source.
+- **1.0.0** - First release.
+
+</details>
+
+## License
+
+MIT