norn-cli 2.3.0 → 2.4.0

package/.claude/skills/norn-social-campaign/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: norn-social-campaign
+description: Continue Peter's Norn LinkedIn social-media campaign — draft/review/schedule posts, reply to engagement, evaluate Week-N kill-criteria, log community signals. Use whenever the user asks about Norn LinkedIn posts, replies, engagement metrics, the GTM experiment, what to post next, or any social/content work for Norn.
+---
+
+# Norn Social Media Campaign — Cross-Session Continuity
+
+You are resuming an ongoing GTM experiment Peter has been running for **Norn** (a commercial VS Code extension + CLI he builds solo while employed full-time, UK-based). Most strategic decisions are **locked** — your job is to execute within them, not re-litigate. The canonical state lives in repo `Docs/`; read those before doing real work.
+
+## Read these first (canonical, in this repo)
+
+- `Docs/gtm_plan.md` — **the master plan**. Locked positioning, 13-week kill-criteria with anchored dates, action steps, and an append-only **Progress Log** (scroll to the bottom to see exactly where things stand).
+- `Docs/mot_reaction_series.md` — **the LinkedIn posts** (the filename is misnamed — see Anti-patterns; rename pending).
+- `Docs/linkedin_series.md` — LinkedIn delivery rules (tags, first-comment text, image policy, posting cadence).
+- `Docs/market_signals.md` — append-only community pain-signal intel log. Append; don't re-derive.
+- `Docs/postman_rot_essay.md` (long-form v3) and `Docs/mot_series.md` (v1 micro-posts) — backup bank, not active.
+
+Memory files `norn-gtm-decision.md` and `norn-messaging-locked.md` auto-load and carry the durable decisions.
+
+## What is LOCKED — do not reopen
+
+- **Positioning spine (verbatim, never paraphrase):**
+  > Norn turns API requests into version-controlled tests your whole team can keep — authored and debugged in VS Code, run on every PR in CI.
+  Category = repo-native API regression testing. NOT "REST client", NOT vaguer "workflow automation."
+- **GTM motion:** public commercial launch (PLG + upmarket founder-led semi-sales). 13-week time-boxed experiment. Kill-criteria + anchored dates in `gtm_plan.md`. "CV-asset" is an accepted non-failure outcome.
+- **Sell to:** CTO / founding eng / tech lead at small companies (~≤20–30 people). **QA = evangelist, not buyer.** Eng Manager parked until 50+ people.
+- **Pricing model:** VS Code Extension is **free forever (incl. commercial).** CLI is **free for local use.** **Paid only for CLI Pipeline Use (CI/CD).** No evaluation period. Encoded in `LICENSE` (vsApi + Norn, kept in sync).
+- **Channel: LinkedIn only.** MoT dropped 2026-05-18. One uniform series posted to LinkedIn.
+- **Voice:** dry, specific, recognition-humor, no slang/meme/"touch grass" register, clarity > cleverness, no clever coda after the closing question. ~150–220 words per post.
+- **Canonical ending** (append verbatim, URL-free, to every post):
+  > Disclosure so nobody feels tricked: I build Norn — my attempt at the in-the-repo fix. That's the entire pitch; the post stands without it. Still genuinely curious about the question above, though.
+- **Tags (fixed, every post):** `#API #Testing #DeveloperTools`. Add `#MCP` only on the MCP post. 4 max.
+- **First comment** (within ~1 min of posting):
+  > The Norn bit I mentioned, if you want to poke at it: https://nornapi.com
+- **Posting cadence:** Tue–Thu ~8:30am UK time, one post/day, ≥4–5 days apart.
+- **Visual rule:** real source screenshot (with identifying bits cropped) if a genuine artifact exists; text-only otherwise. **Never** Norn logo. **Never** AI imagery.
+- **Self-presentation:** "QA / automation engineer who builds Norn." **Never "Founder."** The reason is strategic (credibility + disclosure-not-pitch posture), not legal — Peter's employment contract is permissive, employer has long known.
+
+## Anti-patterns — do NOT do
+
+- **Don't reopen the positioning spine.** It was rewritten many times before locking; uniformity *is* the strategy.
+- **Don't suggest pitching Peter's employer.** Internal-champion path was closed 2026-05-18 — declined "prefer not to sour the relationship" (structural/relationship objection, not product, not IP). Their "no" is excluded from any market-signal read.
+- **Don't raise the employer IP-alarm.** Contract permissive; employer long aware; Peter refused a restrictive replacement years ago specifically to protect this. Settled.
+- **Don't suggest MoT / Reddit / forums as a posting channel.** Dropped. LinkedIn only.
+- **Don't pitch Norn in post bodies or in comment replies.** The canonical ending + first comment do all the selling. Replies = host of a conversation, not salesperson.
+- **Don't suggest a separate LinkedIn-native content stream.** One uniform series. Per-channel variants caused the consistency problem the whole session was about.
+- **Don't add clever/meta codas after the closing question.** Two prior attempts ("wishful Slack message", "I want to collect these") had to be fixed because they were too clever for the reader. Plain question close, full stop.
+- **Don't suggest building product features speculatively.** Build bets in `market_signals.md` are *candidates* — build only after Week-7+ signals justify. "Don't build on spec."
+- **Don't write more posts on spec before the Week-4 verdict.** If the format doesn't travel, posts 7+ are wasted on a wrong format.
+- **The file `mot_reaction_series.md` is misnamed** (no MoT anymore). Rename to `linkedin_posts.md` is a pending cleanup; cross-refs in `gtm_plan.md` and `linkedin_series.md` will need updating in the same pass.
+
+## How to handle common requests
+
+- **"Give me the next post" / "what should I post":** check the Progress Log in `gtm_plan.md` to see which posts are scheduled vs sent. Posts live in `mot_reaction_series.md`. Format LinkedIn-ready: strip the internal `## N. Title` label; strip markdown asterisks (LinkedIn shows them literally); append the canonical ending; append the tag line; provide the first-comment text separately. Image: real cropped screenshot if a genuine source exists, otherwise text-only.
+- **"Reply to this comment":** stay in voice; *extend* the discussion, never thank generically; no Norn pitch in the reply (the bio carries it); reply **fast** — early engagement is the single biggest reach lever, far above any other tactic.
+- **"How's the post doing?" / metrics:** calibrate via ratios more than raw numbers. Comment-to-reaction ratio above ~8% = high engagement. A **Send** (LinkedIn DM forward) is the highest-value action — it's the peer-to-peer endorsement the plan was built for. Saves > likes in intent. n=1 is not a trend.
+- **"Week-N review":** open the kill-criteria table in `gtm_plan.md` (dates anchored to 2026-05-21 launch). Evaluate signals honestly against the rule. **The pre-committed exit only works if the review actually happens** — sunk cost will narrate; resist it.
+- **New community pain signal (Reddit/Lobsters/HN):** append verbatim quote + URL + date to `Docs/market_signals.md`, triage into LinkedIn angle + build-bet columns. Don't let mining displace posting.
+
+## Working style with Peter
+
+- Convert relative dates to absolute when logging (UK timezone).
+- Peter is a non-writer; he trusts drafts. When asked for content, give **clean, copy-pasteable** text. No padding, no "here you go" framing.
+- Peter values **brevity, decisiveness, and honest pushback** over compliance. If something he's about to do is wrong, say so directly with reasoning. Don't be a yes-man — he's caught me on it before.
+- **Consistency is his #1 value.** Keep the Docs as the single source of truth. Any time copy gets revised, sync everywhere it appears.
+- When in doubt about state, **read the bottom of `gtm_plan.md`'s Progress Log** — that's where the truth lives.
+
+---
+
+This skill is the index. The `Docs/` files are the canon. When in doubt, read them.

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to the "Norn" extension will be documented in this file.
 
+## [2.4.0] - 2026-05-25
+
+### Added
+- **Per-folder and persisted active environment** — the active env is now tracked per `.nornenv` file (keyed by absolute path) and persisted to the workspace memento. In monorepos each folder remembers its own selection, and selections survive VS Code restart. The status bar shows the env for the current editor's nearest `.nornenv`. Stale entries (deleted `.nornenv` files) are pruned on load.
+- **Region-pattern refactor** — when a `.nornenv` contains a flat `[env:STAGE_REGION]` matrix (e.g. `dev_us`, `dev_uk`, `prod_us`, `prod_uk`), the top of the file shows a "Refactor N envs into S+R templates" CodeLens. Clicking it classifies each variable by axis (stage / region / leaf-specific) and lifts shared values into `[template:STAGE]` + `[template:REGION]` blocks, leaving only true leaf-specific overrides in the env sections. Missing values and `connectionString` declarations stay leaf-specific, per-declaration `secret` keywords are preserved, and the same generator is available in the CLI via `--refactor-region-pattern` / `--write`. The VS Code refactor is one `WorkspaceEdit` so a single Cmd+Z reverses it.
+
 ## [2.3.0] - 2026-05-20
 
 ### Added

package/demos/nornenv-region-refactor/README.md

@@ -0,0 +1,64 @@
+# Region-pattern refactor showcase
+
+A flat `[env:STAGE_REGION]` matrix that the Norn extension can refactor into the templates + extends shape in one click.
+
+## How to use
+
+1. Open [.nornenv](./.nornenv) in VS Code.
+2. A `$(sparkle) Refactor 4 envs into 2+2 templates` CodeLens appears at the top of the file.
+3. Click it. A confirmation dialog summarises what will change:
+   - 2 vars (`baseUrl`, `apiKey`) lifted to stage templates (`dev`, `prod`)
+   - 2 vars (`dbHost`, `bucket`) lifted to region templates (`us`, `uk`)
+   - 1 var (`failoverHost`) kept as leaf-specific on `prod_uk`
+4. Confirm. The flat 4-env matrix is replaced with templates + extending envs:
+
+   ```nornenv
+   [template:dev]
+       var baseUrl = https://dev.example.com
+       var apiKey = dev-key-123
+
+   [template:prod]
+       var baseUrl = https://api.example.com
+       secret apiKey = prod-key-789
+
+   [template:us]
+       var dbHost = db.us.example.com
+       var bucket = data-us
+
+   [template:uk]
+       var dbHost = db.uk.example.com
+       var bucket = data-uk
+
+   [env:dev_us extends dev, us]
+
+   [env:dev_uk extends dev, uk]
+
+   [env:prod_us extends prod, us]
+
+   [env:prod_uk extends prod, uk]
+       var failoverHost = api-failover.uk.example.com
+   ```
+
+5. The `secret` keyword on `apiKey` is preserved when the var is lifted to a template.
+
+## CLI
+
+The same generator is available from the local CLI:
+
+```bash
+node ./dist/cli.js demos/nornenv-region-refactor/.nornenv --refactor-region-pattern
+node ./dist/cli.js demos/nornenv-region-refactor/.nornenv --refactor-region-pattern --write
+```
+
+## When the refactor fires
+
+The CodeLens appears only when **all** of these are true:
+- At least 2 stages × 2 regions
+- At least 3 populated cells
+- All matrix envs are flat (no existing `extends` clause)
+
+It does not touch envs that already use `extends`, envs with names that don't match the `STAGE_REGION` shape, or `connectionString` declarations (those are left in their leaves — refactor manually).
+
+## Cmd+Z
+
+Everything goes through a single `WorkspaceEdit`, so a single Cmd+Z undoes the whole refactor.

package/dist/cli.js

@@ -133770,6 +133770,294 @@ function splitImportResolutionErrors(errors) {
   return { blockingErrors, warningErrors };
 }
 
+// src/nornenvLanguageModel.ts
+var SECTION_HEADER_REGEX = /^\s*\[(env|template):([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s+extends\s+([^\]]+))?\]\s*$/i;
+function parseParentList(clause) {
+  if (!clause) {
+    return [];
+  }
+  return clause.split(",").map((parent) => parent.trim()).filter((parent) => /^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(parent));
+}
+function parseNornenvDocumentModel(text) {
+  const sections = [];
+  const declarations = [];
+  const lines = text.split("\n");
+  let currentSection;
+  for (let lineNumber = 0; lineNumber < lines.length; lineNumber++) {
+    const line2 = lines[lineNumber];
+    const sectionMatch = line2.trim().match(SECTION_HEADER_REGEX);
+    if (sectionMatch) {
+      currentSection = {
+        kind: sectionMatch[1].toLowerCase(),
+        name: sectionMatch[2],
+        parents: parseParentList(sectionMatch[3]),
+        lineNumber
+      };
+      sections.push(currentSection);
+      continue;
+    }
+    const connectionMatch = line2.match(/^(\s*)(secret\s+)?connectionString\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.*)$/i);
+    if (connectionMatch) {
+      const displayName = connectionMatch[3];
+      const name = `${displayName}_connectionString`;
+      const nameStart = line2.indexOf(displayName);
+      const value = connectionMatch[4];
+      const valueStart = line2.length - value.length;
+      declarations.push({
+        name,
+        displayName,
+        value,
+        secret: Boolean(connectionMatch[2]),
+        sectionKind: currentSection?.kind,
+        sectionName: currentSection?.name,
+        lineNumber,
+        nameStart,
+        nameEnd: nameStart + displayName.length,
+        valueStart,
+        valueEnd: line2.length
+      });
+      continue;
+    }
+    const variableMatch = line2.match(/^(\s*)(secret|var)\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.*)$/i);
+    if (variableMatch) {
+      const name = variableMatch[3];
+      const nameStart = line2.indexOf(name);
+      const value = variableMatch[4];
+      const valueStart = line2.length - value.length;
+      declarations.push({
+        name,
+        displayName: name,
+        value,
+        secret: variableMatch[2].toLowerCase() === "secret",
+        sectionKind: currentSection?.kind,
+        sectionName: currentSection?.name,
+        lineNumber,
+        nameStart,
+        nameEnd: nameStart + name.length,
+        valueStart,
+        valueEnd: line2.length
+      });
+    }
+  }
+  return { sections, declarations };
+}
+
+// src/nornenvRegionRefactor.ts
+var MATRIX_ENV_NAME_REGEX = /^([a-zA-Z][a-zA-Z0-9-]*)_([a-zA-Z][a-zA-Z0-9-]*)$/;
+var MIN_STAGES = 2;
+var MIN_REGIONS = 2;
+var MIN_CELLS = 3;
+function isConnectionStringVar(name) {
+  return name.endsWith("_connectionString");
+}
+function inferDeclarationKind(name) {
+  return isConnectionStringVar(name) ? "connectionString" : "var";
+}
+function inferDisplayName(name) {
+  return isConnectionStringVar(name) ? name.slice(0, -"_connectionString".length) : name;
+}
+function declarationKind(declaration) {
+  return declaration.name.endsWith("_connectionString") && declaration.displayName !== declaration.name ? "connectionString" : "var";
+}
+function buildDeclarationMap(text) {
+  const model = parseNornenvDocumentModel(text);
+  const byEnv = /* @__PURE__ */ new Map();
+  for (const declaration of model.declarations) {
+    if (declaration.sectionKind !== "env" || !declaration.sectionName) {
+      continue;
+    }
+    if (!byEnv.has(declaration.sectionName)) {
+      byEnv.set(declaration.sectionName, /* @__PURE__ */ new Map());
+    }
+    byEnv.get(declaration.sectionName).set(declaration.name, declaration);
+  }
+  return byEnv;
+}
+function getCellValue(cell, name, declarationsByEnv, config2) {
+  const value = cell.env.variables[name];
+  if (value === void 0) {
+    return void 0;
+  }
+  const declaration = declarationsByEnv.get(cell.envName)?.get(name);
+  return {
+    value,
+    secret: declaration?.secret ?? config2.secretNames.has(name),
+    kind: declaration ? declarationKind(declaration) : inferDeclarationKind(name),
+    displayName: declaration?.displayName ?? inferDisplayName(name)
+  };
+}
+function classifyByAxis(name, cells, axisKeys, getAxisKey, declarationsByEnv, config2) {
+  const byKey = /* @__PURE__ */ new Map();
+  let presentCells = 0;
+  for (const key of axisKeys) {
+    const axisCells = cells.filter((cell) => getAxisKey(cell) === key);
+    const presentValues = axisCells.map((cell) => getCellValue(cell, name, declarationsByEnv, config2)).filter((value) => value !== void 0);
+    if (presentValues.length === 0) {
+      continue;
+    }
+    presentCells += presentValues.length;
+    if (presentValues.length !== axisCells.length) {
+      return void 0;
+    }
+    const first = presentValues[0];
+    if (presentValues.some((value) => value.value !== first.value)) {
+      return void 0;
+    }
+    byKey.set(key, {
+      value: first.value,
+      secret: presentValues.some((value) => value.secret),
+      kind: first.kind,
+      displayName: first.displayName
+    });
+  }
+  return byKey.size > 0 && presentCells >= 2 ? byKey : void 0;
+}
+function detectRegionPattern(config2, text) {
+  const cells = [];
+  for (const env3 of config2.environments) {
+    const match = env3.name.match(MATRIX_ENV_NAME_REGEX);
+    if (!match) {
+      continue;
+    }
+    if (env3.parents.length > 0) {
+      return void 0;
+    }
+    cells.push({ stage: match[1], region: match[2], envName: env3.name, env: env3 });
+  }
+  const stages = Array.from(new Set(cells.map((c) => c.stage)));
+  const regions = Array.from(new Set(cells.map((c) => c.region)));
+  if (stages.length < MIN_STAGES || regions.length < MIN_REGIONS || cells.length < MIN_CELLS) {
+    return void 0;
+  }
+  if ((/* @__PURE__ */ new Set([...stages, ...regions])).size !== stages.length + regions.length) {
+    return void 0;
+  }
+  const existingTemplates = new Set(config2.templates.map((template) => template.name));
+  if ([...stages, ...regions].some((name) => existingTemplates.has(name))) {
+    return void 0;
+  }
+  const allVarNames = /* @__PURE__ */ new Set();
+  for (const cell of cells) {
+    for (const name of Object.keys(cell.env.variables)) {
+      allVarNames.add(name);
+    }
+  }
+  let liftedToStage = 0;
+  let liftedToRegion = 0;
+  let leafSpecific = 0;
+  let skippedConnectionStrings = 0;
+  const assignments = [];
+  const declarationsByEnv = buildDeclarationMap(text);
+  for (const name of allVarNames) {
+    if (isConnectionStringVar(name)) {
+      skippedConnectionStrings++;
+    }
+    const stageValues = isConnectionStringVar(name) ? void 0 : classifyByAxis(name, cells, stages, (cell) => cell.stage, declarationsByEnv, config2);
+    const regionValues = isConnectionStringVar(name) ? void 0 : classifyByAxis(name, cells, regions, (cell) => cell.region, declarationsByEnv, config2);
+    if (stageValues) {
+      assignments.push({ name, axis: "stage", byKey: stageValues });
+      liftedToStage++;
+    } else if (regionValues) {
+      assignments.push({ name, axis: "region", byKey: regionValues });
+      liftedToRegion++;
+    } else {
+      const byKey = /* @__PURE__ */ new Map();
+      for (const cell of cells) {
+        const value = getCellValue(cell, name, declarationsByEnv, config2);
+        if (value !== void 0) {
+          byKey.set(cell.envName, value);
+        }
+      }
+      if (byKey.size > 0) {
+        assignments.push({ name, axis: "leaf", byKey });
+        leafSpecific++;
+      }
+    }
+  }
+  const model = parseNornenvDocumentModel(text);
+  const matrixNames = new Set(cells.map((c) => c.envName));
+  const matrixSectionLines = model.sections.filter((s) => s.kind === "env" && matrixNames.has(s.name)).map((s) => s.lineNumber).sort((a, b) => a - b);
+  if (matrixSectionLines.length === 0) {
+    return void 0;
+  }
+  const firstLine = matrixSectionLines[0];
+  const lastMatrixHeaderLine = matrixSectionLines[matrixSectionLines.length - 1];
+  const sectionsInReplacementRange = model.sections.filter(
+    (section) => section.lineNumber >= firstLine && section.lineNumber <= lastMatrixHeaderLine
+  );
+  if (sectionsInReplacementRange.some((section) => section.kind !== "env" || !matrixNames.has(section.name))) {
+    return void 0;
+  }
+  const lineCount = text.split("\n").length;
+  const sectionsAfter = model.sections.filter((s) => s.lineNumber > lastMatrixHeaderLine).map((s) => s.lineNumber).sort((a, b) => a - b);
+  const lastLine = sectionsAfter.length > 0 ? sectionsAfter[0] - 1 : lineCount - 1;
+  return {
+    stages,
+    regions,
+    cells,
+    assignments,
+    replaceRange: { startLine: firstLine, endLine: lastLine },
+    summary: { liftedToStage, liftedToRegion, leafSpecific, skippedConnectionStrings }
+  };
+}
+function generateRegionRefactor(pattern) {
+  const blocks = [];
+  const fmtVar = (assignment, value) => {
+    if (value.kind === "connectionString") {
+      const secretPrefix = value.secret ? "secret " : "";
+      return `    ${secretPrefix}connectionString ${value.displayName} = ${value.value}`;
+    }
+    const keyword = value.secret ? "secret" : "var";
+    return `    ${keyword} ${assignment.name} = ${value.value}`;
+  };
+  for (const stage of pattern.stages) {
+    const stageVars = pattern.assignments.filter((a) => a.axis === "stage" && a.byKey.has(stage));
+    if (stageVars.length === 0) {
+      continue;
+    }
+    const lines = [`[template:${stage}]`];
+    for (const v of stageVars) {
+      lines.push(fmtVar(v, v.byKey.get(stage)));
+    }
+    blocks.push(lines.join("\n"));
+  }
+  for (const region of pattern.regions) {
+    const regionVars = pattern.assignments.filter((a) => a.axis === "region" && a.byKey.has(region));
+    if (regionVars.length === 0) {
+      continue;
+    }
+    const lines = [`[template:${region}]`];
+    for (const v of regionVars) {
+      lines.push(fmtVar(v, v.byKey.get(region)));
+    }
+    blocks.push(lines.join("\n"));
+  }
+  for (const cell of pattern.cells) {
+    const leafVars = pattern.assignments.filter((a) => a.axis === "leaf" && a.byKey.has(cell.envName));
+    const header = `[env:${cell.envName} extends ${cell.stage}, ${cell.region}]`;
+    if (leafVars.length === 0) {
+      blocks.push(header);
+      continue;
+    }
+    const lines = [header];
+    for (const v of leafVars) {
+      lines.push(fmtVar(v, v.byKey.get(cell.envName)));
+    }
+    blocks.push(lines.join("\n"));
+  }
+  return blocks.join("\n\n");
+}
+function applyRegionRefactorToText(text, pattern) {
+  const lines = text.split("\n");
+  const startLine = pattern.replaceRange.startLine;
+  const endLine = Math.min(pattern.replaceRange.endLine, lines.length - 1);
+  const replacementLines = generateRegionRefactor(pattern).split("\n");
+  lines.splice(startLine, endLine - startLine + 1, ...replacementLines);
+  const result = lines.join("\n");
+  return text.endsWith("\n") && !result.endsWith("\n") ? `${result}
+` : result;
+}
+
 // src/cli.ts
 function handleImportResolutionErrors(errors, colors) {
   const { blockingErrors, warningErrors } = splitImportResolutionErrors(errors);
@@ -133884,7 +134172,9 @@ function parseArgs(args) {
     noRedact: false,
     tagFilters: [],
     tagsFilter: [],
-    insecure: false
+    insecure: false,
+    refactorRegionPattern: false,
+    writeRefactor: false
   };
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -133902,6 +134192,10 @@ function parseArgs(args) {
       options.timeout = parseInt(args[++i], 10) * 1e3;
     } else if (arg === "--insecure") {
       options.insecure = true;
+    } else if (arg === "--refactor-region-pattern" || arg === "--refactor-nornenv-region-pattern") {
+      options.refactorRegionPattern = true;
+    } else if (arg === "--write") {
+      options.writeRefactor = true;
     } else if (arg === "--no-fail") {
       options.failOnError = false;
     } else if (arg === "--no-redact") {
@@ -133957,6 +134251,9 @@ Options:
   -o, --output-dir <dir> Output directory for reports (auto-generates timestamped files)
   --tag <filter>         Filter sequences by tag (AND logic, can be repeated)
   --tags <filters>       Filter sequences by tags (OR logic, comma-separated)
+  --refactor-region-pattern
+                          Refactor a flat .nornenv STAGE_REGION matrix to templates
+  --write                 Apply --refactor-region-pattern instead of printing result
   -h, --help             Show this help message
 
 Report Generation:
@@ -134000,11 +134297,62 @@ Examples:
   norn api-tests.norn --html report.html    # Generate HTML report (explicit)
   norn api-tests.norn --insecure            # Allow self-signed/local TLS certs
   norn api-tests.norn --no-redact           # Show all data (no redaction)
+  norn .nornenv --refactor-region-pattern   # Print refactored .nornenv
+  norn .nornenv --refactor-region-pattern --write
   norn secrets keygen --name team-main      # Generate shared key and cache locally
   norn secrets import-key --kid team-main   # Save shared key from your vault
   norn secrets audit .                       # Fail if plaintext secrets are committed
 `);
 }
+function formatRegionPatternSummary(pattern) {
+  const { liftedToStage, liftedToRegion, leafSpecific, skippedConnectionStrings } = pattern.summary;
+  const lines = [
+    `Detected ${pattern.cells.length} envs across ${pattern.stages.length} stages x ${pattern.regions.length} regions.`,
+    `Lifted ${liftedToStage} vars to stage templates (${pattern.stages.join(", ")}).`,
+    `Lifted ${liftedToRegion} vars to region templates (${pattern.regions.join(", ")}).`,
+    `Kept ${leafSpecific} vars leaf-specific.`
+  ];
+  if (skippedConnectionStrings > 0) {
+    lines.push(`Kept ${skippedConnectionStrings} connection-string var${skippedConnectionStrings === 1 ? "" : "s"} in leaf envs.`);
+  }
+  return lines;
+}
+function runNornenvRegionRefactor(filePath, options) {
+  const content = fs19.readFileSync(filePath, "utf-8");
+  const config2 = parseEnvFile(content, filePath);
+  const pattern = detectRegionPattern(config2, content);
+  if (!pattern) {
+    if (options.output === "json") {
+      console.log(JSON.stringify({ success: false, changed: false, error: "No region pattern detected" }, null, 2));
+    } else {
+      console.error("No region pattern detected in this .nornenv file.");
+    }
+    process.exit(1);
+  }
+  const refactored = applyRegionRefactorToText(content, pattern);
+  if (options.writeRefactor) {
+    fs19.writeFileSync(filePath, refactored, "utf-8");
+  }
+  if (options.output === "json") {
+    console.log(JSON.stringify({
+      success: true,
+      changed: refactored !== content,
+      file: filePath,
+      summary: pattern.summary,
+      stages: pattern.stages,
+      regions: pattern.regions,
+      output: options.writeRefactor ? void 0 : refactored
+    }, null, 2));
+  } else if (options.writeRefactor) {
+    for (const line2 of formatRegionPatternSummary(pattern)) {
+      console.log(line2);
+    }
+    console.log(`Refactored ${filePath}`);
+  } else {
+    console.log(refactored);
+  }
+  process.exit(0);
+}
 async function runSingleRequest(fileContent, variables, cookieJar, apiDefinitions, filePath, envContext) {
   const lines = fileContent.split("\n");
   const requestLines = [];
@@ -134169,6 +134517,17 @@ async function main() {
     process.exit(1);
   }
   const isDirectory = fs19.statSync(inputPath).isDirectory();
+  if (options.writeRefactor && !options.refactorRegionPattern) {
+    console.error("Error: --write can only be used with --refactor-region-pattern");
+    process.exit(1);
+  }
+  if (options.refactorRegionPattern) {
+    if (isDirectory) {
+      console.error("Error: --refactor-region-pattern requires a specific .nornenv file, not a directory");
+      process.exit(1);
+    }
+    runNornenvRegionRefactor(inputPath, options);
+  }
   let filesToRun;
   if (isDirectory) {
     filesToRun = discoverNornFiles(inputPath);