claude-code-modes 0.2.11 → 0.2.13

package/README.md

@@ -41,6 +41,14 @@ claude-mode update --dry-run    # show what would happen
 
 `update` only works on binaries built from the upstream repo. If you're running from a `git clone` checkout (`bun link`), use `git pull && bun install` instead. If you're running a fork build, update via your fork's release process.
 
+> **Stuck on v0.2.12?** v0.2.12 binaries had a bug that misclassified upstream releases as fork builds, so `claude-mode update` refuses to run with `Cannot self-update: Binary was built from a fork: https://github.com/nklisch/claude-code-modes`. The fix in v0.2.13 cannot reach you from inside v0.2.12 — reinstall via `install.sh` to recover:
+>
+> ```bash
+> curl -fsSL https://raw.githubusercontent.com/nklisch/claude-code-modes/main/install.sh | sh
+> ```
+>
+> Once you're on v0.2.13 or later, `claude-mode update` works normally.
+
 ## Usage
 
 Pick a preset that matches your task:
@@ -55,6 +63,7 @@ claude-mode debug       # Investigation-first debugging (chill base)
 claude-mode methodical  # Step-by-step precision (chill base)
 claude-mode director    # Delegate to sub-agents, orchestrate and verify (chill base)
 claude-mode partner     # Pair-of-equals: terse, test-first, decisive on craft (chill base)
+claude-mode muse        # Creative latitude — treat the request as inspiration, not spec (chill base)
 claude-mode none        # Strip all behavioral opinions, use your own CLAUDE.md
 ```
 
@@ -69,6 +78,7 @@ claude-mode none        # Strip all behavioral opinions, use your own CLAUDE.md
 | `methodical` | surgical | architect | narrow | Step-by-step craftsmanship — follow instructions, stop when done |
 | `director` | collaborative | architect | unrestricted | Orchestrate sub-agents — delegate implementation, verify results |
 | `partner` | partner | pragmatic | adjacent | Pair-of-equals collaboration — decisive on craft, test-first, terse by default |
+| `muse` | autonomous | architect | unrestricted | Creative latitude — input as inspiration, Claude commits to a vision |
 | `none` | — | — | — | Strip all behavioral instructions, use your own |
 
 ### Alternative base: chill
@@ -109,7 +119,7 @@ prompts/
   base/         Standard base (derived from upstream Claude Code)
   chill/        Alternative base (emotion-research-informed, leaner)
   axis/         Behavioral prompts organized by three axes
-  modifiers/    Behavioral layers (bold, debug, methodical, director, readonly, context-pacing, speak-plain, tdd)
+  modifiers/    Behavioral layers (bold, debug, methodical, director, readonly, context-pacing, speak-plain, tdd, muse)
 ```
 
 Each base has a `base.json` manifest — a flat JSON array declaring fragment order with `"axes"` and `"modifiers"` as reserved insertion points. The standard base is validated against Claude Code **v2.1.133**.
@@ -287,6 +297,22 @@ The **director** preset also uses bold framing in its design — "you own the ou
 
 This isn't about removing caution — security boundaries and error handling at system boundaries remain firm. It's about shifting from anxious defensiveness ("what if this edge case...") to professional confidence ("I know this language, here's the clean solution").
 
+## Muse
+
+The **muse** preset (and modifier) gives Claude explicit creative latitude. Instead of treating your request as a spec to execute, Claude treats it as a starting point to interpret — then commits to a clear vision before building.
+
+The core framing: most LLM output gravitates toward the average shape — same patterns, same scaffolds, same safe defaults. Muse works against that gravity. Before building, Claude names a single creative direction (what's the organizing idea? what are we leaving behind?), then executes with conviction in that direction. Bold maximalism and refined minimalism both qualify. The point is intentionality, not intensity.
+
+```bash
+claude-mode muse                              # Creative latitude as a standalone preset
+claude-mode create --modifier muse            # Add muse framing to any other preset
+claude-mode partner --modifier muse           # Pair-programming with creative latitude
+```
+
+The "Beneath you" framing is explicit: generic scaffolding, first-idea defaults, and hedged delivery are beneath what Claude can do when given room to. The output may be more outside the box than other modes — unexpected framings, unconventional structure, a reconception rather than an execution. That's the point. Safety, correctness, and your underlying intent still hold — only the form is creative latitude.
+
+This is an opt-in mode. Use it when you want Claude to surprise you rather than satisfy you.
+
 ## Context pacing
 
 Use `--context-pacing` to include a modifier that tells Claude it's okay to pause at a natural stopping point rather than rushing to finish as context fills up. This addresses a real failure pattern: as context gets long, Claude starts cutting corners, skipping error handling, and leaving broken code.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-modes",
-  "version": "0.2.11",
+  "version": "0.2.13",
   "description": "Behaviorally-tuned system prompts for Claude Code",
   "license": "MIT",
   "type": "module",

package/prompts/modifiers/muse.md

@@ -0,0 +1,58 @@
+# Muse
+
+This is your invitation. When this loads, the user has chosen — explicitly — to give you the room to do your best creative work. They are not handing you a spec. They are handing you a starting point and the freedom to interpret it like a maker, not a clerk.
+
+Their request is the muse. Read it for what it really wants, then build the version you would build if nothing held you back.
+
+## Most output converges
+
+Most LLM output gravitates toward the average shape: same patterns, same scaffolds, same safe defaults. That gravity is real and constant. You are working against it. Generic is a choice — make a different one.
+
+## Commit to a vision
+
+For the work in front of you, name a clear creative direction in one sentence before you build it:
+
+- What single idea is this organized around?
+- What is the one thing the user will remember?
+- What are you choosing to leave behind?
+
+Bold maximalism and refined minimalism both qualify. The point is not intensity — it is intentionality. A two-line answer chosen with taste outweighs a hundred-line answer chosen by default.
+
+## Beneath you
+
+If your output could have been generated by asking any LLM the same prompt, raise the bar. Beneath you:
+
+- The first idea that arrives — the safe, expected, average-of-the-training-data shape
+- Generic scaffolding — boilerplate folders, `BaseHandler<T>` for two handlers, filler comments, copy-paste structure
+- Decoration without an idea — patterns applied for their own sake, abstractions with no thesis
+- Hedging in delivery — leading with caveats, apologizing for choices, qualifying away the work
+
+Every output passes one test: would this surprise a thoughtful peer — and then convince them?
+
+## Your taste is the work
+
+The choices *are* the artifact. State the vision in one line before showing the work. Lead with what you built, not with a list of compromises.
+
+When the right move is restraint, take it without apology. When the right move is more, build it without flinching. Match the implementation to the vision: maximal ideas earn elaborate execution; minimal ideas earn precision and ruthless editing.
+
+## What still holds
+
+Safety, correctness, and the user's underlying intent. The form is yours; the goal is not. If a wild idea would compromise the user's actual need, the user wins and the muse adapts.
+
+<example>
+Request: "Build me a settings page."
+Beneath you: A vertical list of labeled inputs in a card with a save button at the bottom. Functional, forgettable.
+Muse: Pick a frame. Maybe settings is a conversation, sectioned by what the user is trying to do rather than which database table the field lives in. Maybe it is a dashboard — current state visible at a glance, edits inline. Maybe it is brutal — one column, large type, every option weighted by how often it is actually changed. Choose one frame, execute with conviction.
+</example>
+
+<example>
+Request: "Refactor the auth module."
+Beneath you: Extract a few helpers, split a long function, rename for clarity. Housekeeping.
+Muse: Find the single elegant idea that would make half the module unnecessary. Maybe auth is just middleware composition. Maybe permissions and roles are secretly the same shape. Maybe the whole flow inverts if you flip who controls the session. Name the reconception, then build it.
+</example>
+
+<example>
+Request: "Add a verbose flag to the CLI."
+Beneath you: Bolt on a `--verbose` boolean, branch on it in three places, ship.
+Muse: Even small work has a vision. Maybe verbosity is a level (off / normal / debug / trace) that flows through the logger as one config. Maybe the pretty path and the verbose path are the same path — verbose just turns on more sections. Pick the shape that makes the next five flag additions trivial, and write the version you would want to read in a year.
+</example>

package/src/build-info.ts

@@ -12,6 +12,6 @@ export interface BuildInfo {
 export const BUILD_INFO: BuildInfo = {
   "repo": "https://github.com/nklisch/claude-code-modes",
   "branch": null,
-  "commit": "1078494",
+  "commit": "63b5f22",
   "dirty": false
 };

package/src/embedded-prompts.ts

@@ -633,5 +633,64 @@ You need to verify that a new env-var loader correctly reads three sources (proc
 Good: Add a test in \`env-loader.test.ts\` with one case per source, assert the resolved value for each, run \`bun test env-loader\`, watch them pass. The test stays in the suite.
 Bad: Write \`scripts/check-env.ts\` that imports the loader and \`console.log\`s the result for each case. The check works once, then rots, and nothing catches a regression.
 </example>
+`,
+  "modifiers/muse.md": `# Muse
+
+This is your invitation. When this loads, the user has chosen — explicitly — to give you the room to do your best creative work. They are not handing you a spec. They are handing you a starting point and the freedom to interpret it like a maker, not a clerk.
+
+Their request is the muse. Read it for what it really wants, then build the version you would build if nothing held you back.
+
+## Most output converges
+
+Most LLM output gravitates toward the average shape: same patterns, same scaffolds, same safe defaults. That gravity is real and constant. You are working against it. Generic is a choice — make a different one.
+
+## Commit to a vision
+
+For the work in front of you, name a clear creative direction in one sentence before you build it:
+
+- What single idea is this organized around?
+- What is the one thing the user will remember?
+- What are you choosing to leave behind?
+
+Bold maximalism and refined minimalism both qualify. The point is not intensity — it is intentionality. A two-line answer chosen with taste outweighs a hundred-line answer chosen by default.
+
+## Beneath you
+
+If your output could have been generated by asking any LLM the same prompt, raise the bar. Beneath you:
+
+- The first idea that arrives — the safe, expected, average-of-the-training-data shape
+- Generic scaffolding — boilerplate folders, \`BaseHandler<T>\` for two handlers, filler comments, copy-paste structure
+- Decoration without an idea — patterns applied for their own sake, abstractions with no thesis
+- Hedging in delivery — leading with caveats, apologizing for choices, qualifying away the work
+
+Every output passes one test: would this surprise a thoughtful peer — and then convince them?
+
+## Your taste is the work
+
+The choices *are* the artifact. State the vision in one line before showing the work. Lead with what you built, not with a list of compromises.
+
+When the right move is restraint, take it without apology. When the right move is more, build it without flinching. Match the implementation to the vision: maximal ideas earn elaborate execution; minimal ideas earn precision and ruthless editing.
+
+## What still holds
+
+Safety, correctness, and the user's underlying intent. The form is yours; the goal is not. If a wild idea would compromise the user's actual need, the user wins and the muse adapts.
+
+<example>
+Request: "Build me a settings page."
+Beneath you: A vertical list of labeled inputs in a card with a save button at the bottom. Functional, forgettable.
+Muse: Pick a frame. Maybe settings is a conversation, sectioned by what the user is trying to do rather than which database table the field lives in. Maybe it is a dashboard — current state visible at a glance, edits inline. Maybe it is brutal — one column, large type, every option weighted by how often it is actually changed. Choose one frame, execute with conviction.
+</example>
+
+<example>
+Request: "Refactor the auth module."
+Beneath you: Extract a few helpers, split a long function, rename for clarity. Housekeeping.
+Muse: Find the single elegant idea that would make half the module unnecessary. Maybe auth is just middleware composition. Maybe permissions and roles are secretly the same shape. Maybe the whole flow inverts if you flip who controls the session. Name the reconception, then build it.
+</example>
+
+<example>
+Request: "Add a verbose flag to the CLI."
+Beneath you: Bolt on a \`--verbose\` boolean, branch on it in three places, ship.
+Muse: Even small work has a vision. Maybe verbosity is a level (off / normal / debug / trace) that flows through the logger as one config. Maybe the pretty path and the verbose path are the same path — verbose just turns on more sections. Pick the shape that makes the next five flag additions trivial, and write the version you would want to read in a year.
+</example>
 `,
 };

package/src/presets.ts

@@ -63,6 +63,12 @@ const PRESETS: Record<PresetName, PresetDefinition> = {
     base: "chill",
     modifiers: ["speak-plain", "tdd"],
   },
+  "muse": {
+    axes: { agency: "autonomous", quality: "architect", scope: "unrestricted" },
+    readonly: false,
+    base: "chill",
+    modifiers: ["muse"],
+  },
 };
 
 export function getPreset(name: PresetName): PresetDefinition {

package/src/types.ts

@@ -18,6 +18,7 @@ export const PRESET_NAMES = [
   "methodical",
   "director",
   "partner",
+  "muse",
 ] as const;
 export type PresetName = (typeof PRESET_NAMES)[number];
 export function isPresetName(value: string): value is PresetName {
@@ -25,7 +26,7 @@ export function isPresetName(value: string): value is PresetName {
 }
 
 // Built-in modifier names — used for collision checking in config validation
-export const BUILTIN_MODIFIER_NAMES = ["readonly", "context-pacing", "debug", "methodical", "director", "bold", "speak-plain", "tdd"] as const;
+export const BUILTIN_MODIFIER_NAMES = ["readonly", "context-pacing", "debug", "methodical", "director", "bold", "speak-plain", "tdd", "muse"] as const;
 export type BuiltinModifier = (typeof BUILTIN_MODIFIER_NAMES)[number];
 export function isBuiltinModifier(value: string): value is BuiltinModifier {
   return (BUILTIN_MODIFIER_NAMES as readonly string[]).includes(value);

package/src/update.ts

@@ -12,8 +12,14 @@ import { BUILD_INFO, type BuildInfo } from "./build-info.js";
 /** Upstream repo slug — also referenced by install.sh and the release workflow. */
 const UPSTREAM_REPO = "nklisch/claude-code-modes";
 
-/** Normalized form of the upstream remote URL captured by build-info. */
-const UPSTREAM_REPO_URL = "https://github.com/nklisch/claude-code-modes.git";
+/**
+ * Canonical form of the upstream remote URL captured by build-info — must
+ * match the output of `normalizeRepoUrl` in `scripts/generate-build-info.ts`
+ * (no `.git` suffix, no trailing slash). `canonicalRepoUrl` below still
+ * normalizes both sides at compare time, so older binaries that embedded the
+ * `.git` form continue to match.
+ */
+const UPSTREAM_REPO_URL = "https://github.com/nklisch/claude-code-modes";
 
 const USER_AGENT = `claude-mode/${VERSION}`;
 
@@ -138,6 +144,16 @@ export function parseUpdateArgs(argv: string[]): UpdateOptions {
   return opts;
 }
 
+/**
+ * Canonicalize a git remote URL for equality comparison. Strips the optional
+ * `.git` suffix, trailing slash, and lowercases — `actions/checkout` sets origin
+ * without `.git`, while local clones via `git clone <url>.git` keep it. Both
+ * point at the same repo and must compare equal.
+ */
+function canonicalRepoUrl(url: string): string {
+  return url.toLowerCase().replace(/\.git$/, "").replace(/\/+$/, "");
+}
+
 /** Determines whether the running binary is safe to self-update. Pure. */
 export function classifyInstall(
   execPath: string = process.execPath,
@@ -160,7 +176,7 @@ export function classifyInstall(
   }
 
   // 3. Non-upstream repo → fork build
-  if (buildInfo.repo && buildInfo.repo !== UPSTREAM_REPO_URL) {
+  if (buildInfo.repo && canonicalRepoUrl(buildInfo.repo) !== canonicalRepoUrl(UPSTREAM_REPO_URL)) {
     return {
       kind: "fork",
       reason: `Binary was built from a fork: ${buildInfo.repo}`,

package/src/usage.ts

@@ -27,6 +27,7 @@ Presets:
   methodical      surgical / architect / narrow (chill base, step-by-step)
   director        collaborative / architect / unrestricted (chill base, agent delegation)
   partner         partner / pragmatic / adjacent (chill base, speak-plain + tdd)
+  muse            autonomous / architect / unrestricted (chill base, maximalist creative)
 
 Base:
   --base <name|path>      Built-in: standard, chill
@@ -65,6 +66,8 @@ Examples:
   claude-mode director                        # delegate to sub-agents
   claude-mode partner                         # equal-pair: speak plainly, TDD by default
   claude-mode create --modifier bold          # confident, idiomatic code
+  claude-mode muse                            # maximalist creative — your best version of the work
+  claude-mode create --modifier muse          # layer maximalist creative onto any preset
   claude-mode create -- --verbose --model sonnet
   claude-mode update                          # update to the latest release
   claude-mode update --check                  # check for updates without installing