@v0idd0/message-next-step 0.1.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,264 @@
+# message-next-step
+
+[![License: MIT](https://img.shields.io/badge/license-MIT-0F172A.svg)](LICENSE)
+[![Node ≥18](https://img.shields.io/badge/node-%E2%89%A518-0F172A)](package.json)
+
+**[Web app](https://tells.voiddo.com/message-next-step/?ref=message-next-step-readme)** · **[Live compare page](https://tells.voiddo.com/message-next-step/compare-chatgpt-gemini.html?ref=message-next-step-readme)** · **[Packaged compare brief](compare-chatgpt-gemini.md)** · **[Deep Dive](https://tells.voiddo.com/deep-dive/?ref=message-next-step-readme)** · **[Signal toolkit](https://tells.voiddo.com/signal-toolkit/?ref=message-next-step-readme)** · **[GitHub](https://github.com/voidd0/message-next-step)** · **[npm](https://www.npmjs.com/package/@v0idd0/message-next-step)** · **[All tools](https://tools.voiddo.com/?ref=message-next-step-catalog-readme)** · **[Contact](mailto:support@voiddo.com)**
+
+---
+
+`message-next-step` is a deterministic checker for one narrow question:
+
+What should you do with this message right now?
+
+It reads one incoming message and suggests one next step:
+
+- `reply now`
+- `wait`
+- `ask one concrete question`
+- `move to a call`
+- `let it go`
+
+It does not pretend to read the whole relationship. It gives a fast, explainable first pass when you are stuck between overreacting and overinterpreting in dating, recruiter, workplace, client, support, or family threads.
+
+It also works as a narrower, faster alternative to ChatGPT or Gemini when the real question is not "help me think forever" but "what is the next move on this one message?"
+
+## Why this exists
+
+The paid product is [`tells`](https://tells.voiddo.com/?ref=message-next-step-readme), which reads what people leave unsaid across messages, people, and profiles.
+
+But many users do not start with "analyze the whole pattern." They start with a smaller operational question:
+
+- Should I answer this now?
+- Are they asking for something real, or just creating pressure?
+- Is this vague enough that I need one clarifying question?
+- Is texting the wrong bandwidth for this?
+
+That same question shows up outside dating too:
+
+- recruiter loops where timing and seriousness are unclear
+- client or account messages that may need a cleaner boundary
+- support escalations that are getting too heated for chat
+- family or cofounder threads where the real question is whether text is still working
+
+`message-next-step` is that free first step. It gives a deterministic action recommendation before the user commits to a deeper paid read.
+
+## Install
+
+```bash
+npm install -g @v0idd0/message-next-step
+```
+
+## Web app
+
+Use the browser version here:
+
+```text
+https://tells.voiddo.com/message-next-step/?ref=message-next-step-readme
+```
+
+If you want the browser-side AI-alternative framing first:
+
+```text
+https://tells.voiddo.com/message-next-step/compare-chatgpt-gemini.html?ref=message-next-step-readme
+```
+
+If you want the packaged compare brief for npm/GitHub readers:
+
+```text
+compare-chatgpt-gemini.md
+```
+
+If the blocker is follow-up timing rather than reply content, use the sibling checker here:
+
+```text
+https://tells.voiddo.com/double-text-risk/?ref=message-next-step-readme
+```
+
+If the incoming message is warm but still too vague to treat as a real yes, check that layer here first:
+
+```text
+https://tells.voiddo.com/soft-yes-or-no/?ref=message-next-step-readme
+```
+
+## Usage
+
+```bash
+message-next-step "Can you confirm by Friday whether you want me to send the draft?"
+```
+
+```bash
+cat incoming.txt | message-next-step
+```
+
+```bash
+message-next-step --json "Maybe later. We'll see when things calm down."
+```
+
+```bash
+message-next-step --file incoming.txt
+```
+
+## Example output
+
+```text
+posture: direct
+directness: 7.9/10
+ambiguity:  2.5/10
+pressure:   3.2/10
+escalation: 1/10
+avoidance:  1/10
+call shift: 1/10
+
+next step: reply now
+why: The text names a usable next step without much ambiguity.
+- There is enough concrete signal to answer directly.
+
+next:
+Use tells when one message is not enough and you need the thread, the person, or the pattern over time.
+- quick next paid step: https://tells.voiddo.com/deep-dive/?ref=message-next-step-cli
+- recurring reads: https://tells.voiddo.com/?ref=message-next-step-cli
+```
+
+## What it scores
+
+The tool uses transparent heuristics around six dimensions:
+
+- `directness` — is there a real ask, timing, or next step?
+- `ambiguity` — is timing or intent being left blurry?
+- `pressure` — is force doing more work than content?
+- `escalation` — is this message getting too hot for text?
+- `avoidance` — is the sender stalling instead of deciding?
+- `call shift` — are there enough cues that text is the wrong channel?
+
+The recommendation is intentionally conservative. It is designed to stop bad reactive moves, not to invent certainty.
+
+## Good use cases
+
+- tense client, recruiter, or support texts
+- dating or relationship messages with mixed clarity
+- workplace follow-ups where you are unsure whether to push
+- family messages where a call may be better than more texting
+- any incoming message where your real question is "what do I do next?"
+
+## Bad use cases
+
+- therapy, legal, or crisis guidance
+- deception detection
+- full relationship analysis
+- multi-message pattern reading
+
+Those are outside this tool's scope. If the stakes are real and one message is not enough, use `tells`.
+
+## Why not just use ChatGPT or Gemini?
+
+Because the first question is often operational, not interpretive.
+
+For a narrow next-step call, a deterministic tool is faster and easier to trust:
+
+- no API key
+- no prompt fiddling
+- no latency roulette
+- no surprise token bill
+- same input gives the same output
+
+Then, if the user needs the deeper read, the next step is not "more tokens." It is `tells`, which is built around subtext, conspicuous absence, pressure, and likely next move.
+
+If you want the side-by-side framing inside the live browser route:
+
+```text
+https://tells.voiddo.com/message-next-step/compare-chatgpt-gemini.html?ref=message-next-step-readme
+```
+
+If you want the package-side compare brief instead:
+
+```text
+compare-chatgpt-gemini.md
+```
+
+## Paid next step
+
+When the one-message answer is not enough, the paid ladder is simple:
+
+- `Deep Dive` — `$19 once` for one loaded thread or one recurring person
+- `Starter` — `$14.99/mo` for repeated message reading
+- `Practitioner` — `$99.99/mo` for coaches, recruiters, mediators, trainers, or client-facing teams using this with clients
+
+If the message-level answer is not enough, the fastest paid handoff is usually `Deep Dive`:
+
+```text
+https://tells.voiddo.com/deep-dive/?ref=message-next-step-readme
+```
+
+If you still want the wider browser-first free path first:
+
+```text
+https://tells.voiddo.com/signal-toolkit/?ref=message-next-step-readme
+```
+
+Start here:
+
+```text
+https://tells.voiddo.com/message-next-step/?ref=message-next-step-readme
+```
+
+## Related free checkers
+
+If the next-step question turns out to be the wrong layer, route into the narrower free tool first:
+
+- `double-text-risk` for deciding whether another outbound follow-up is too soon or too pushy: `https://tells.voiddo.com/double-text-risk/?ref=message-next-step-related-readme`
+- `soft-yes-or-no` for deciding whether the incoming message is polite interest, real intent, or a warm stall before you commit to a direct reply: `https://tells.voiddo.com/soft-yes-or-no/?ref=message-next-step-related-readme`
+- `replytone` for checking whether your drafted response sounds clear, warm, or too forceful: `https://tells.voiddo.com/replytone/?ref=message-next-step-related-readme`
+- `ambiguity-meter` for scoring whether the incoming message is vague, evasive, or mixed: `https://tells.voiddo.com/ambiguity-meter/?ref=message-next-step-related-readme`
+- `call-not-text` for deciding whether the thread is already too compressed or heated for another message: `https://tells.voiddo.com/call-not-text/?ref=message-next-step-related-readme`
+- `ghost-or-go` for deciding whether ongoing silence means wait, one final ping, or close the loop: `https://tells.voiddo.com/ghost-or-go/?ref=message-next-step-related-readme`
+- `raincheck-or-run` for deciding whether repeated reschedules and no-new-time messages are still workable or already a stall pattern: `https://tells.voiddo.com/raincheck-or-run/?ref=message-next-step-related-readme`
+
+## Programmatic API
+
+```javascript
+import { analyzeMessageNextStep, formatReport } from "@v0idd0/message-next-step";
+
+const result = analyzeMessageNextStep("You always do this. Call me right now!!!");
+
+console.log(result.decision.action);
+console.log(formatReport(result));
+```
+
+## Development
+
+```bash
+npm test
+node bin/message-next-step.js "Maybe later. We'll see when things calm down."
+```
+
+## More from the studio
+
+See [`from-the-studio.md`](from-the-studio.md) for the wider vøiddo catalogue.
+
+## Compare surface
+
+- live compare page: `https://tells.voiddo.com/message-next-step/compare-chatgpt-gemini.html?ref=message-next-step-readme`
+- packaged compare brief: [`compare-chatgpt-gemini.md`](compare-chatgpt-gemini.md)
+
+If you are positioning this tool against general-purpose AI assistants, use the dedicated comparison asset:
+
+[`compare-chatgpt-gemini.md`](compare-chatgpt-gemini.md)
+
+## Best next free exits
+
+- `replytone` for checking whether your drafted response sounds warm, clear, or too forceful before you send it: `https://tells.voiddo.com/replytone/?ref=message-next-step-readme`
+- `double-text-risk` for deciding whether a follow-up is timely, needy, or better left unsent: `https://tells.voiddo.com/double-text-risk/?ref=message-next-step-readme`
+- `soft-yes-or-no` for deciding whether the incoming wording is a real yes, a warm maybe, or a polite stall before you over-commit to a reply: `https://tells.voiddo.com/soft-yes-or-no/?ref=message-next-step-readme`
+- `ambiguity-meter` for checking whether the incoming message is vague, evasive, or mixed enough to justify a clarifier instead of a direct answer: `https://tells.voiddo.com/ambiguity-meter/?ref=message-next-step-readme`
+- `call-not-text` for deciding whether the thread has outgrown text and needs a call, pause, or firmer channel switch: `https://tells.voiddo.com/call-not-text/?ref=message-next-step-readme`
+- `ghost-or-go` for deciding whether ongoing silence after this message means wait, one final ping, or close the loop: `https://tells.voiddo.com/ghost-or-go/?ref=message-next-step-readme`
+- `raincheck-or-run` for deciding whether repeated schedule slips, delays, or "maybe later" loops are still genuine or already a stall pattern: `https://tells.voiddo.com/raincheck-or-run/?ref=message-next-step-readme`
+
+## License
+
+MIT.
+
+---
+
+Built by [vøiddo](https://voiddo.com/) — a small studio shipping AI-flavoured products, free dev tools, Chrome extensions and weird browser games.

package/bin/message-next-step.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import { analyzeMessageNextStep, formatReport } from "../src/index.js";
+
+function printHelp() {
+  console.log(`message-next-step
+
+Usage:
+  message-next-step "text to analyze"
+  cat message.txt | message-next-step
+  message-next-step --file message.txt
+  message-next-step --json "Can we talk later?"
+`);
+}
+
+function parseArgs(argv) {
+  const args = [...argv];
+  let json = false;
+  let file = null;
+  const textParts = [];
+
+  while (args.length) {
+    const arg = args.shift();
+    if (arg === "--help" || arg === "-h") {
+      return { help: true };
+    }
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg === "--file") {
+      file = args.shift();
+      continue;
+    }
+    textParts.push(arg);
+  }
+
+  return { help: false, json, file, text: textParts.join(" ").trim() };
+}
+
+async function readStdin() {
+  if (process.stdin.isTTY) {
+    return "";
+  }
+  return new Promise((resolve) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve(data.trim()));
+  });
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.help) {
+    printHelp();
+    process.exit(0);
+  }
+
+  let input = options.text;
+  if (options.file) {
+    input = fs.readFileSync(options.file, "utf8").trim();
+  }
+  if (!input) {
+    input = await readStdin();
+  }
+  if (!input) {
+    printHelp();
+    process.exit(1);
+  }
+
+  const result = analyzeMessageNextStep(input);
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(formatReport(result));
+}
+
+main().catch((error) => {
+  console.error(`message-next-step: ${error.message}`);
+  process.exit(1);
+});

package/compare-chatgpt-gemini.md

@@ -0,0 +1,82 @@
+# message-next-step vs ChatGPT or Gemini
+
+`message-next-step` is not trying to replace a general-purpose model.
+
+It is trying to win a narrower, high-frequency moment:
+
+> "I already have the incoming message. I just need to know whether to reply now, wait, ask one clarifier, move to a call, or let it go."
+
+That is where a deterministic checker beats a blank prompt box.
+
+## When message-next-step is the better first step
+
+- You want a stable `reply now`, `wait`, `ask one question`, `move to a call`, or `let it go` call.
+- You do not want to write prompts, add fake context, or compare three slightly different model answers.
+- You are checking a dating, recruiter, client, support, family, or workplace thread where the immediate next move matters more than broad interpretation.
+- You want the same message to score the same way every time.
+
+## When ChatGPT or Gemini is still useful
+
+- You want rewrites, brainstorming, or roleplay.
+- You want a broad assistant rather than a narrow next-step call.
+- You need long-form drafting more than decision support.
+
+## The practical difference
+
+| question | message-next-step | ChatGPT / Gemini |
+| --- | --- | --- |
+| "What should I do with this message right now?" | deterministic action + why | depends on prompt and model variance |
+| "Can I re-check the same message later?" | yes, same input = same output | not reliably |
+| "Do I need an account or API key?" | no | usually yes |
+| "Can it rewrite five responses for me?" | no, narrow checker by design | yes |
+| "Can it read the deeper recurring pattern behind this person?" | no, move into tells for that | not from one prompt alone |
+
+## What each tool is actually good at
+
+- Use `message-next-step` when the immediate question is the next action on one incoming message and you want a stable `reply now`, `wait`, `ask one question`, `move to a call`, or `let it go` call.
+- Use ChatGPT or Gemini when you already know the decision and want rewrite options, brainstorming, roleplay, or longer drafting help.
+- Use `ambiguity-meter` when the main question is whether the message is genuinely clear, vague, or evasive before you decide what to do with it.
+- Use `soft-yes-or-no` when the message sounds warm but still might be a polite stall instead of a real commitment.
+- Use `replytone` when you already wrote the answer and want to know whether it sounds warm, clear, or pushy.
+- Use `double-text-risk` when the timing of your next outbound follow-up matters more than the meaning of the current message.
+- Use `call-not-text` when the real question is no longer the reply itself, but whether text is the wrong channel for the pressure, heat, or complexity in the thread.
+- Use `raincheck-or-run` when the message is mainly another reschedule, delay, or "maybe later" loop and the decision is whether to rebook or walk away.
+- Use `tells` when one message is not enough and the issue is the recurring person, loaded thread, or wider pattern over time.
+
+## Where tells fits
+
+`message-next-step` is the free first door.
+
+If the real problem is not one message but one recurring person, one loaded thread, or one pattern of pressure, avoidance, or mixed signals, the better next step is `tells`.
+
+- `Deep Dive` — `$19 once` for one loaded case
+- `Starter` — `$14.99/mo` for recurring message reads
+- `Practitioner` — `$99.99/mo` for coaches, recruiters, mediators, trainers, and client-facing teams
+
+Use the browser checker:
+
+```text
+https://tells.voiddo.com/message-next-step/?ref=message-next-step-compare-md
+```
+
+If you want the browser-side compare page first:
+
+```text
+https://tells.voiddo.com/message-next-step/compare-chatgpt-gemini.html?ref=message-next-step-compare-md
+```
+
+If one message is not enough:
+
+```text
+https://tells.voiddo.com/deep-dive/?ref=message-next-step-compare-md
+```
+
+If you want the wider free cluster first:
+
+```text
+https://tells.voiddo.com/signal-toolkit/?ref=message-next-step-compare-md
+```
+
+---
+
+Built by [vøiddo](https://voiddo.com/) — a small studio shipping AI-flavoured products, free dev tools, Chrome extensions and weird browser games.

package/from-the-studio.md

@@ -0,0 +1,69 @@
+# From the same studio
+
+This package is one piece of [vøiddo](https://voiddo.com/), a small studio that ships AI-flavoured products, free dev tools, Chrome extensions and weird browser games.
+
+## Flagship path
+
+| product | what it does |
+|---|---|
+| [**tells**](https://tells.voiddo.com/?ref=message-next-step-studio) | opinionated AI that reads what people do not say in messages, threads, and profiles |
+| [**Deep Dive**](https://tells.voiddo.com/deep-dive/?ref=message-next-step-studio) | the fastest paid handoff when one message-level action call is not enough and the user needs the fuller thread or person read |
+| [**Signal toolkit**](https://tells.voiddo.com/signal-toolkit/?ref=message-next-step-studio) | browser-first hub for the tells micro-tools when the user still wants a free/cheap checkpoint first |
+| [**scrb**](https://scrb.voiddo.com/?ref=message-next-step-studio) | AI product description generator for Amazon, Etsy, Shopify, and eBay |
+| [**rankd**](https://rankd.voiddo.com/?ref=message-next-step-studio) | opinionated cultural verdicts on music, books, and films |
+
+## Related free tools
+
+| tool | one-line |
+|---|---|
+| [message-next-step vs ChatGPT/Gemini](https://tells.voiddo.com/message-next-step/compare-chatgpt-gemini.html?ref=message-next-step-studio) | comparison page for people deciding whether they need a deterministic next-step checker or a broader general AI assistant |
+| [`message-next-step` packaged compare brief](compare-chatgpt-gemini.md) | npm/GitHub-ready acquisition brief for install-surface readers deciding whether they need a deterministic next-step checker or a broader general model |
+| [replytone](https://tells.voiddo.com/replytone/?ref=message-next-step-studio) | score an outgoing draft for warmth, clarity, pressure, and urgency |
+| [soft-yes-or-no](https://tells.voiddo.com/soft-yes-or-no/?ref=message-next-step-studio) | decide whether a warm-but-vague message is real interest, a soft no, or a polite stall |
+| [ambiguity-meter](https://tells.voiddo.com/ambiguity-meter/?ref=message-next-step-studio) | check one incoming message for mixed signals and missing next steps |
+| [double-text-risk](https://tells.voiddo.com/double-text-risk/?ref=message-next-step-studio) | score whether a follow-up is timely, needy, or better left unsent |
+| [call-not-text](https://tells.voiddo.com/call-not-text/?ref=message-next-step-studio) | decide whether the thread is already too messy, heated, or compressed for more texting |
+| [ghost-or-go](https://tells.voiddo.com/ghost-or-go/?ref=message-next-step-studio) | decide whether silence means wait, send one final ping, or close the loop |
+| [raincheck-or-run](https://tells.voiddo.com/raincheck-or-run/?ref=message-next-step-studio) | decide whether repeated reschedules are still workable or already a stall pattern |
+| [profile-red-flags](https://tells.voiddo.com/profile-red-flags/?ref=message-next-step-studio) | triage one profile for vagueness, pressure, cynicism, and effort |
+| [All free tools](https://tools.voiddo.com/?ref=message-next-step-studio) | the wider vøiddo CLI and browser-tools catalogue |
+
+## When the free pass is not enough
+
+`message-next-step` is meant to stop one bad reactive move before the user needs a fuller read of the thread or person.
+
+That applies across dating, recruiter loops, workplace friction, client or support escalations, and family threads where the next move matters more than a broad interpretation.
+
+The paid next steps are explicit:
+
+- `Deep Dive` — `$19 once` for one loaded thread or one recurring person
+- `Starter` — `$14.99/mo` for repeat message reads
+- `Practitioner` — `$99.99/mo` for coach, recruiter, mediator, trainer, or client-facing team workflows
+
+If the message-level answer is not enough, the best next stop is usually `Deep Dive`:
+
+```text
+https://tells.voiddo.com/deep-dive/?ref=message-next-step-studio
+```
+
+If the user still wants a wider browser-first free path before buying, send them here instead:
+
+```text
+https://tells.voiddo.com/signal-toolkit/?ref=message-next-step-studio
+```
+
+## Best next free exits
+
+- [replytone](https://tells.voiddo.com/replytone/?ref=message-next-step-studio) if the user already drafted the response and wants a warmth / clarity / pressure check before sending
+- [double-text-risk](https://tells.voiddo.com/double-text-risk/?ref=message-next-step-studio) if the real blocker is follow-up timing instead of reply content
+- [soft-yes-or-no](https://tells.voiddo.com/soft-yes-or-no/?ref=message-next-step-studio) if the incoming message sounds warm but still not concrete enough to treat as a real yes
+- [ambiguity-meter](https://tells.voiddo.com/ambiguity-meter/?ref=message-next-step-studio) if the incoming wording is so vague that the user first needs an ambiguity read
+- [call-not-text](https://tells.voiddo.com/call-not-text/?ref=message-next-step-studio) if the thread has outgrown text and needs a call / pause / channel switch decision
+- [ghost-or-go](https://tells.voiddo.com/ghost-or-go/?ref=message-next-step-studio) if the next question becomes silence management after this message lands
+- [raincheck-or-run](https://tells.voiddo.com/raincheck-or-run/?ref=message-next-step-studio) if the message is mostly another delay, cancellation, or no-new-time reschedule loop
+
+Need support or a custom workflow? Contact `support@voiddo.com`.
+
+---
+
+Built by [vøiddo](https://voiddo.com/) — a small studio shipping AI-flavoured products, free dev tools, Chrome extensions and weird browser games.

package/package.json

@@ -0,0 +1,117 @@
+{
+  "name": "@v0idd0/message-next-step",
+  "version": "0.1.0",
+  "description": "message-next-step — free deterministic incoming-message checker and faster ChatGPT alternative for dating, workplace, recruiter, client, and family threads when you need to decide whether to reply now, wait, ask one question, move to a call, or let it go.",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "message-next-step": "./bin/message-next-step.js"
+  },
+  "scripts": {
+    "test": "node test.js",
+    "stage:site": "bash ./scripts/stage-site.sh"
+  },
+  "keywords": [
+    "message-next-step",
+    "next-step-checker",
+    "texting",
+    "message-analysis",
+    "incoming-message-analyzer",
+    "mixed-signals",
+    "incoming-message",
+    "incoming-text",
+    "reply-or-wait",
+    "wait-or-reply",
+    "should-i-reply",
+    "should-i-answer-this-message",
+    "should-i-respond-now",
+    "reply-checker",
+    "reply-decision",
+    "reply-now-or-wait",
+    "what-should-i-do-with-this-message",
+    "how-to-answer-this-text",
+    "follow-up-decision",
+    "follow-up-triage",
+    "how-to-respond",
+    "message-decision",
+    "message-triage",
+    "message-response-decision",
+    "chatgpt-alternative",
+    "gemini-alternative",
+    "ai-writing-alternative",
+    "email-reply-decision",
+    "incoming-email-next-step",
+    "recruiter-message",
+    "recruiter-follow-up",
+    "client-message",
+    "client-follow-up",
+    "support-escalation",
+    "support-reply",
+    "family-conflict",
+    "family-thread-next-step",
+    "move-to-call",
+    "move-this-to-a-call",
+    "clarifying-question",
+    "need-one-clarifying-question",
+    "support-thread-next-step",
+    "customer-thread-next-step",
+    "recruiter-next-step",
+    "client-next-step",
+    "email-next-step",
+    "reply-later-or-now",
+    "respond-or-wait",
+    "when-to-reply-to-a-text",
+    "when-to-reply-to-an-email",
+    "date-text-next-step",
+    "vague-text-next-step",
+    "mixed-signal-reply",
+    "reschedule-message-decision",
+    "message-escalation-checker",
+    "what-should-i-reply",
+    "what-do-i-do-with-this-text",
+    "what-do-i-do-with-this-email",
+    "should-i-call-instead-of-text",
+    "texting-anxiety",
+    "communication",
+    "relationships",
+    "dating",
+    "workplace",
+    "recruiting",
+    "customer-support",
+    "account-management",
+    "coaching",
+    "heuristics",
+    "cli",
+    "voiddo",
+    "tells"
+  ],
+  "author": "vøiddo <support@voiddo.com> (https://voiddo.com)",
+  "license": "MIT",
+  "homepage": "https://tells.voiddo.com/message-next-step/?ref=message-next-step-npm",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/voidd0/message-next-step.git"
+  },
+  "bugs": {
+    "url": "https://github.com/voidd0/message-next-step/issues",
+    "email": "support@voiddo.com"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "compare-chatgpt-gemini.md",
+    "LICENSE",
+    "from-the-studio.md"
+  ],
+  "funding": {
+    "type": "individual",
+    "url": "https://voiddo.com/contact/"
+  }
+}

package/src/index.js

@@ -0,0 +1,247 @@
+const URGENCY_PHRASES = [
+  "asap",
+  "urgent",
+  "today",
+  "by tonight",
+  "right now",
+  "need an answer",
+  "let me know today",
+  "before friday",
+  "can you confirm"
+];
+
+const DELAY_PHRASES = [
+  "maybe later",
+  "we'll see",
+  "not right now",
+  "another time",
+  "sometime",
+  "for now",
+  "eventually",
+  "when things calm down"
+];
+
+const SPECIFICITY_PHRASES = [
+  "tomorrow",
+  "friday",
+  "monday",
+  "confirm by",
+  "at 3",
+  "call at",
+  "meet at",
+  "send me",
+  "i can do",
+  "let's talk",
+  "reply by",
+  "next week"
+];
+
+const CALL_PHRASES = [
+  "call me",
+  "can we talk",
+  "let's talk",
+  "jump on a call",
+  "phone call",
+  "talk later",
+  "need to talk"
+];
+
+const BLAME_PHRASES = [
+  "you're overthinking",
+  "you always do this",
+  "don't start",
+  "calm down",
+  "that's not what i meant",
+  "why are you making this about you",
+  "you're making this harder"
+];
+
+const SOFTENERS = [
+  "thanks",
+  "appreciate",
+  "glad",
+  "happy to",
+  "makes sense",
+  "understand"
+];
+
+function clamp(value, min = 0, max = 10) {
+  return Math.max(min, Math.min(max, value));
+}
+
+function round1(value) {
+  return Math.round(value * 10) / 10;
+}
+
+function countMatches(text, phrases) {
+  return phrases.reduce((count, phrase) => {
+    const escaped = phrase.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(`\\b${escaped}\\b`, "gi");
+    const hits = text.match(regex);
+    return count + (hits ? hits.length : 0);
+  }, 0);
+}
+
+function buildDecision(metrics, counters) {
+  const reasons = [];
+  let action = "ask one concrete question";
+  let summary =
+    "The message is not clear enough on timing or intent to justify filling the blanks with optimism.";
+
+  if (
+    metrics.escalation >= 6 ||
+    (metrics.callShift >= 5.5 && metrics.pressure >= 5) ||
+    (metrics.callShift >= 4.5 && counters.exclamations >= 2)
+  ) {
+    action = "move to a call";
+    summary =
+      "The text is carrying enough heat or compression that another round of texting will probably distort it further.";
+    reasons.push("Escalation is high enough that text is the wrong bandwidth.");
+  } else if (metrics.directness >= 6.5 && metrics.pressure <= 5 && metrics.ambiguity <= 4.5) {
+    action = "reply now";
+    summary = "The text names a usable next step without much ambiguity.";
+    reasons.push("There is enough concrete signal to answer directly.");
+  } else if (metrics.avoidance >= 5 && metrics.pressure <= 4.5) {
+    action = "wait";
+    summary = "The message leans toward delay rather than a clean request. Pushing now is unlikely to improve clarity.";
+    reasons.push("Delay language is stronger than commitment language.");
+  } else if (metrics.blame >= 6.5 && metrics.directness <= 4.5) {
+    action = "let it go";
+    summary = "The text shifts the frame onto your reaction without offering much constructive direction back.";
+    reasons.push("Blame or minimising language is doing more work than the actual issue.");
+  } else {
+    reasons.push("One concrete follow-up will surface whether the sender has a real next step or not.");
+  }
+
+  if (metrics.ambiguity >= 5) {
+    reasons.push("Timing or intent stays unresolved in the current wording.");
+  }
+  if (metrics.pressure >= 6) {
+    reasons.push("The message carries more force than detail.");
+  }
+  if (counters.questions >= 3) {
+    reasons.push("Stacked questions increase friction without adding clarity.");
+  }
+
+  return {
+    action,
+    summary,
+    reasons: [...new Set(reasons)].slice(0, 3)
+  };
+}
+
+function buildFollowUpPrompts(metrics) {
+  const prompts = [];
+
+  if (metrics.ambiguity >= 5) {
+    prompts.push("What exactly are you asking me to decide or confirm?");
+  }
+  if (metrics.directness < 5.5) {
+    prompts.push("What timing are you actually proposing?");
+  }
+  if (metrics.pressure >= 6) {
+    prompts.push("I can answer this better on a call than in fragments here.");
+  }
+  if (metrics.avoidance >= 5) {
+    prompts.push("If now is not the right time, when should I revisit this?");
+  }
+
+  return [...new Set(prompts)].slice(0, 3);
+}
+
+export function analyzeMessageNextStep(input) {
+  const text = String(input || "").trim();
+  if (!text) {
+    throw new Error("message-next-step needs message text");
+  }
+
+  const lower = text.toLowerCase();
+  const exclamations = (text.match(/!/g) || []).length;
+  const questions = (text.match(/\?/g) || []).length;
+  const uppercaseWords = (text.match(/\b[A-Z]{3,}\b/g) || []).length;
+  const words = text.split(/\s+/).filter(Boolean);
+  const sentences = Math.max(
+    1,
+    text.split(/[.!?]+/).map((part) => part.trim()).filter(Boolean).length
+  );
+
+  const urgencyHits = countMatches(lower, URGENCY_PHRASES);
+  const delayHits = countMatches(lower, DELAY_PHRASES);
+  const specificityHits = countMatches(lower, SPECIFICITY_PHRASES);
+  const callHits = countMatches(lower, CALL_PHRASES);
+  const blameHits = countMatches(lower, BLAME_PHRASES);
+  const softenerHits = countMatches(lower, SOFTENERS);
+
+  const directness = clamp(4 + specificityHits * 1.35 + urgencyHits * 0.8 - delayHits * 0.6);
+  const ambiguity = clamp(3 + delayHits * 1.25 - specificityHits * 0.5);
+  const pressure = clamp(2 + urgencyHits * 1.25 + blameHits * 0.8 + uppercaseWords * 0.9 + exclamations * 0.45 - softenerHits * 0.35);
+  const escalation = clamp(1 + blameHits * 1.8 + callHits * 0.9 + exclamations * 0.8 + uppercaseWords * 0.9);
+  const avoidance = clamp(1 + delayHits * 1.35 - specificityHits * 0.25);
+  const callShift = clamp(1 + callHits * 2.4 + Math.max(0, escalation - 5) * 0.45);
+
+  const metrics = {
+    directness: round1(directness),
+    ambiguity: round1(ambiguity),
+    pressure: round1(pressure),
+    escalation: round1(escalation),
+    avoidance: round1(avoidance),
+    callShift: round1(callShift)
+  };
+
+  let posture = "mixed";
+  if (metrics.directness >= 6.5 && metrics.ambiguity <= 4.5) {
+    posture = "direct";
+  } else if (metrics.avoidance >= 5) {
+    posture = "avoidant";
+  } else if (metrics.escalation >= 6 || metrics.callShift >= 5.5) {
+    posture = "heated";
+  }
+
+  return {
+    posture,
+    metrics,
+    decision: buildDecision(metrics, { questions, exclamations }),
+    followUps: buildFollowUpPrompts(metrics),
+    counters: {
+      words: words.length,
+      sentences,
+      questions
+    }
+  };
+}
+
+export function formatReport(result) {
+  const lines = [
+    `posture: ${result.posture}`,
+    `directness: ${result.metrics.directness}/10`,
+    `ambiguity:  ${result.metrics.ambiguity}/10`,
+    `pressure:   ${result.metrics.pressure}/10`,
+    `escalation: ${result.metrics.escalation}/10`,
+    `avoidance:  ${result.metrics.avoidance}/10`,
+    `call shift: ${result.metrics.callShift}/10`,
+    "",
+    `next step: ${result.decision.action}`,
+    `why: ${result.decision.summary}`
+  ];
+
+  for (const reason of result.decision.reasons) {
+    lines.push(`- ${reason}`);
+  }
+
+  if (result.followUps.length) {
+    lines.push("", "follow-up prompts:");
+    result.followUps.forEach((prompt, index) => {
+      lines.push(`${index + 1}. ${prompt}`);
+    });
+  }
+
+  lines.push(
+    "",
+    "next:",
+    "Use tells when one message is not enough and you need the thread, the person, or the pattern over time.",
+    "- quick next paid step: https://tells.voiddo.com/deep-dive/?ref=message-next-step-cli",
+    "- recurring reads: https://tells.voiddo.com/?ref=message-next-step-cli"
+  );
+
+  return lines.join("\n");
+}