@medicine-wheel/creative-orientation 0.5.3

package/README.md

@@ -0,0 +1,89 @@
+# @medicine-wheel/creative-orientation
+
+Which orientation does this situation call for?
+
+> [!WARNING]
+> **Experimental alpha.** Part of the Medicine Wheel Developer Suite, which is
+> under active development. APIs change between patch versions and all packages
+> move in lockstep — pin exact versions. See
+> [ALPHA.md](https://github.com/jgwill/medicine-wheel/blob/main/ALPHA.md).
+
+## Why it exists
+
+Problem-solving is not the degraded case. It is the **correct** case for a
+specific situation: something worked, it stopped working, restore it. Creating
+is correct for a different one: bring into being a state that has never
+existed.
+
+They produce different structures. Problem-solving oscillates back to a
+baseline — which is exactly right when you are below the baseline. Creating
+advances toward an outcome. Using the wrong one is how rigorous work goes in
+circles: chart an oscillating goal and you build a very careful machine for
+returning to where you started.
+
+This package answers the routing question and nothing else.
+
+## The discriminator
+
+A feeling of urgency is not evidence. Under pressure every situation feels like
+a fire. One question separates them:
+
+> **Is there a prior state you are restoring?**
+
+If you can name it and it genuinely existed — fire. Gap analysis is the right
+instrument. If you cannot, you are creating, and difference-closing language
+will mislead you, because there is no baseline to close toward.
+
+## Usage
+
+```ts
+import { readOrientation, worthSaying } from '@medicine-wheel/creative-orientation';
+
+const reading = readOrientation({
+  outcome: 'catch cross-service contract breaks',
+  restores: null,
+});
+
+reading.orientation;      // 'advancing'
+reading.route;            // 'structural-tension'
+worthSaying(reading);     // true — the phrasing and the situation disagree
+reading.advice;
+// "This outcome is phrased as removing something, but nothing is being
+//  restored. Elimination framing here optimises against a list of known
+//  failures rather than toward the state you actually want."
+```
+
+The baseline claim decides the route. Vocabulary only ever contributes signals,
+because `reduce latency` is a correct outcome during an incident and a symptom
+worth surfacing as a product vision. A blocklist would be wrong in precisely
+the situation where that vocabulary is right.
+
+## It advises; it does not refuse
+
+Nothing here blocks a caller. A package that refuses is a package people learn
+to route around, and routing around it teaches nothing. The reading is
+returned, the disagreement is named, and the caller proceeds — because
+sometimes the caller knows something the check does not.
+
+## Where it sits
+
+```
+creative-orientation ......... the gate
+    ├── gap-analysis ......... the fire path
+    └── structural-tension ... the advancing path
+```
+
+`@medicine-wheel/brainstorming` calls this on every outcome statement it emits,
+including its own questions. That is the load-bearing use: an elimination-shaped
+option label, once selected by a human, stops looking like an agent's bias and
+starts looking like a requirement.
+
+## Status
+
+First release. The surface is small on purpose — the judgement of whether a
+claimed baseline is *real* stays with a person, and everything around that
+socket is deterministic so it can be tested and cannot be forgotten under load.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,100 @@
+/**
+ * @medicine-wheel/creative-orientation
+ *
+ * Which orientation does this situation call for?
+ *
+ * Problem-solving is not the degraded case. It is the correct case for a
+ * specific situation: something worked, it stopped working, restore it.
+ * Creating is the correct case for a different one: bring into being a state
+ * that has never existed. They produce different structures — one oscillates
+ * back to a baseline, one advances toward an outcome — and using the wrong
+ * one is how rigorous work goes in circles.
+ *
+ * This module answers the routing question and nothing else. It does not
+ * decide, it does not block. A caller that disagrees proceeds, because
+ * sometimes the caller knows something the check does not.
+ *
+ * @packageDocumentation
+ */
+/**
+ * The one question that separates the two orientations.
+ *
+ * A feeling of urgency is not evidence — under pressure everything feels like
+ * a fire. What distinguishes them is whether there is a prior state you are
+ * returning to. If you can name it and it genuinely existed, the situation is
+ * a fire. If you cannot, you are creating, and difference-closing language
+ * will mislead you because there is no baseline to close toward.
+ */
+export interface SituationClaim {
+    /** What the caller wants. */
+    outcome: string;
+    /**
+     * The prior state being restored, if any. A string means the caller claims
+     * one existed; `null` means they claim none did.
+     */
+    restores: string | null;
+    /** Optional evidence that the claimed prior state was real. */
+    evidence?: string;
+}
+export type Orientation = 'advancing' | 'oscillating' | 'ambiguous';
+export type Route = 'gap-analysis' | 'structural-tension';
+export interface OrientationSignal {
+    kind: 'vocabulary' | 'baseline' | 'outcome-shape';
+    detail: string;
+    /** Which orientation this signal points toward. */
+    suggests: Orientation;
+}
+export interface OrientationReading {
+    orientation: Orientation;
+    /** Where this situation should be taken next. */
+    route: Route;
+    signals: OrientationSignal[];
+    /**
+     * Present when the reading disagrees with how the outcome was phrased.
+     * Advisory — never a refusal.
+     */
+    advice?: string;
+    /** The outcome restated in advancing form, when that is what is called for. */
+    suggestedOutcome?: string;
+}
+/**
+ * Words that describe the removal of something unwanted rather than the
+ * presence of something wanted.
+ *
+ * These are **evidence, not verdicts**. "Reduce latency" is a correct outcome
+ * when the forest is on fire. The same phrase as a product vision is a symptom
+ * worth surfacing. A blocklist would be wrong in exactly the situation where
+ * this vocabulary is right.
+ */
+export declare const ELIMINATION_MARKERS: readonly ["avoid", "prevent", "reduce", "eliminate", "stop", "fix", "catch", "remove", "minimize", "minimise", "mitigate", "resolve the problem", "get rid of", "bridge the gap", "close the gap", "gap between"];
+/** Words that describe a state coming into being. */
+export declare const ADVANCING_MARKERS: readonly ["bring into being", "establish", "create", "arrives", "exists", "becomes", "holds", "carries", "is able to", "can now"];
+/**
+ * Read a situation and say which orientation it calls for.
+ *
+ * The baseline claim decides the route; vocabulary only ever contributes
+ * signals. A caller who names a real prior state gets routed to gap analysis
+ * even if they phrased the outcome beautifully — and a caller who names none
+ * gets routed to structural tension even if every word they used was
+ * elimination-shaped.
+ */
+export declare function readOrientation(claim: SituationClaim): OrientationReading;
+/**
+ * Restate an elimination-shaped outcome as a desired state.
+ *
+ * Deliberately mechanical and deliberately incomplete: it produces a prompt for
+ * a human or agent to finish, not a finished sentence. A confident rewrite here
+ * would be a machine deciding what someone wants.
+ */
+export declare function reorient(outcome: string): string;
+/** Convenience: the route alone, for callers that only need to dispatch. */
+export declare function routeFor(claim: SituationClaim): Route;
+/**
+ * Does this reading warrant interrupting the caller?
+ *
+ * True only when the orientation and the phrasing disagree. Advice on a
+ * situation the caller already framed correctly is noise, and noise is how
+ * checks get switched off.
+ */
+export declare function worthSaying(reading: OrientationReading): boolean;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc;IAC7B,6BAA6B;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,aAAa,GAAG,WAAW,CAAC;AAEpE,MAAM,MAAM,KAAK,GAAG,cAAc,GAAG,oBAAoB,CAAC;AAE1D,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,YAAY,GAAG,UAAU,GAAG,eAAe,CAAC;IAClD,MAAM,EAAE,MAAM,CAAC;IACf,mDAAmD;IACnD,QAAQ,EAAE,WAAW,CAAC;CACvB;AAED,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,WAAW,CAAC;IACzB,iDAAiD;IACjD,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,EAAE,iBAAiB,EAAE,CAAC;IAC7B;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+EAA+E;IAC/E,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAID;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,mNAItB,CAAC;AAEX,qDAAqD;AACrD,eAAO,MAAM,iBAAiB,mIAGpB,CAAC;AAYX;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,cAAc,GAAG,kBAAkB,CAwDzE;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAIhD;AAED,4EAA4E;AAC5E,wBAAgB,QAAQ,CAAC,KAAK,EAAE,cAAc,GAAG,KAAK,CAErD;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAEhE"}

package/dist/index.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * @medicine-wheel/creative-orientation
+ *
+ * Which orientation does this situation call for?
+ *
+ * Problem-solving is not the degraded case. It is the correct case for a
+ * specific situation: something worked, it stopped working, restore it.
+ * Creating is the correct case for a different one: bring into being a state
+ * that has never existed. They produce different structures — one oscillates
+ * back to a baseline, one advances toward an outcome — and using the wrong
+ * one is how rigorous work goes in circles.
+ *
+ * This module answers the routing question and nothing else. It does not
+ * decide, it does not block. A caller that disagrees proceeds, because
+ * sometimes the caller knows something the check does not.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ADVANCING_MARKERS = exports.ELIMINATION_MARKERS = void 0;
+exports.readOrientation = readOrientation;
+exports.reorient = reorient;
+exports.routeFor = routeFor;
+exports.worthSaying = worthSaying;
+// ─── Vocabulary ───────────────────────────────────────────────────
+/**
+ * Words that describe the removal of something unwanted rather than the
+ * presence of something wanted.
+ *
+ * These are **evidence, not verdicts**. "Reduce latency" is a correct outcome
+ * when the forest is on fire. The same phrase as a product vision is a symptom
+ * worth surfacing. A blocklist would be wrong in exactly the situation where
+ * this vocabulary is right.
+ */
+exports.ELIMINATION_MARKERS = [
+    'avoid', 'prevent', 'reduce', 'eliminate', 'stop', 'fix', 'catch',
+    'remove', 'minimize', 'minimise', 'mitigate', 'resolve the problem',
+    'get rid of', 'bridge the gap', 'close the gap', 'gap between',
+];
+/** Words that describe a state coming into being. */
+exports.ADVANCING_MARKERS = [
+    'bring into being', 'establish', 'create', 'arrives', 'exists',
+    'becomes', 'holds', 'carries', 'is able to', 'can now',
+];
+const WORD_BOUNDARY = /[^a-z]+/;
+function mentions(haystack, needle) {
+    const text = haystack.toLowerCase();
+    if (needle.includes(' '))
+        return text.includes(needle);
+    return text.split(WORD_BOUNDARY).includes(needle);
+}
+// ─── Reading a situation ──────────────────────────────────────────
+/**
+ * Read a situation and say which orientation it calls for.
+ *
+ * The baseline claim decides the route; vocabulary only ever contributes
+ * signals. A caller who names a real prior state gets routed to gap analysis
+ * even if they phrased the outcome beautifully — and a caller who names none
+ * gets routed to structural tension even if every word they used was
+ * elimination-shaped.
+ */
+function readOrientation(claim) {
+    const signals = [];
+    const eliminationHits = exports.ELIMINATION_MARKERS.filter(m => mentions(claim.outcome, m));
+    for (const hit of eliminationHits) {
+        signals.push({
+            kind: 'vocabulary',
+            detail: `"${hit}" in outcome position describes removing something, not a state that exists`,
+            suggests: 'oscillating',
+        });
+    }
+    const advancingHits = exports.ADVANCING_MARKERS.filter(m => mentions(claim.outcome, m));
+    for (const hit of advancingHits) {
+        signals.push({
+            kind: 'vocabulary',
+            detail: `"${hit}" names a state coming into being`,
+            suggests: 'advancing',
+        });
+    }
+    const hasBaseline = typeof claim.restores === 'string' && claim.restores.trim().length > 0;
+    signals.push(hasBaseline
+        ? {
+            kind: 'baseline',
+            detail: `a prior state is claimed: ${claim.restores}${claim.evidence ? ` (evidence: ${claim.evidence})` : ' — no evidence given'}`,
+            suggests: 'oscillating',
+        }
+        : {
+            kind: 'baseline',
+            detail: 'no prior state is being restored — there is no baseline to close toward',
+            suggests: 'advancing',
+        });
+    const orientation = hasBaseline ? 'oscillating' : 'advancing';
+    const route = hasBaseline ? 'gap-analysis' : 'structural-tension';
+    const reading = { orientation, route, signals };
+    // The two disagreements worth surfacing.
+    if (!hasBaseline && eliminationHits.length > 0) {
+        reading.advice =
+            'This outcome is phrased as removing something, but nothing is being restored. ' +
+                'Elimination framing here optimises against a list of known failures rather than ' +
+                'toward the state you actually want. Restate it as the state that will exist.';
+        reading.suggestedOutcome = reorient(claim.outcome);
+    }
+    else if (hasBaseline && !claim.evidence) {
+        reading.advice =
+            'A prior state is claimed but not evidenced. Under pressure every situation feels ' +
+                'like a fire. Name when this state existed, or the routing rests on a feeling.';
+    }
+    return reading;
+}
+/**
+ * Restate an elimination-shaped outcome as a desired state.
+ *
+ * Deliberately mechanical and deliberately incomplete: it produces a prompt for
+ * a human or agent to finish, not a finished sentence. A confident rewrite here
+ * would be a machine deciding what someone wants.
+ */
+function reorient(outcome) {
+    const hit = exports.ELIMINATION_MARKERS.find(m => mentions(outcome, m));
+    if (!hit)
+        return outcome;
+    return `[restate without "${hit}"] What state exists once this is true? — ${outcome}`;
+}
+/** Convenience: the route alone, for callers that only need to dispatch. */
+function routeFor(claim) {
+    return readOrientation(claim).route;
+}
+/**
+ * Does this reading warrant interrupting the caller?
+ *
+ * True only when the orientation and the phrasing disagree. Advice on a
+ * situation the caller already framed correctly is noise, and noise is how
+ * checks get switched off.
+ */
+function worthSaying(reading) {
+    return typeof reading.advice === 'string';
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@medicine-wheel/creative-orientation",
+  "version": "0.5.3",
+  "description": "Which orientation a situation calls for — advancing toward a state that has never existed, or restoring one that did. Routes to structural tension or to gap analysis.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "keywords": [
+    "medicine-wheel",
+    "creative-orientation",
+    "structural-tension",
+    "robert-fritz",
+    "advancing",
+    "oscillating"
+  ],
+  "author": "jgwill",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jgwill/medicine-wheel.git",
+    "directory": "src/creative-orientation"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0"
+  }
+}