Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/voidd0/ghost-or-go

ghost-or-go — deterministic silence checker: decide whether to wait, send one final ping, escalate, or close the loop
https://github.com/voidd0/ghost-or-go

chatgpt-alternative cli communication dating follow-up gemini-alternative ghosting nodejs npm recruiting silence tells texting voiddo

Last synced: 6 days ago
JSON representation

ghost-or-go — deterministic silence checker: decide whether to wait, send one final ping, escalate, or close the loop

Awesome Lists containing this project

README 

          
# ghost-or-go



[![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/ghost-or-go/?ref=ghost-or-go-readme)** · **[Live compare page](https://tells.voiddo.com/ghost-or-go/compare-chatgpt-gemini.html?ref=ghost-or-go-readme)** · **[Packaged compare brief](compare-chatgpt-gemini.md)** · **[Deep Dive](https://tells.voiddo.com/deep-dive/?ref=ghost-or-go-readme)** · **[Signal toolkit](https://tells.voiddo.com/signal-toolkit/?ref=ghost-or-go-readme)** · **[npm](https://www.npmjs.com/package/@v0idd0/ghost-or-go)** · **[All tools](https://tools.voiddo.com/?ref=ghost-or-go-catalog-readme)** · **[Support](https://voiddo.com/contact/?ref=ghost-or-go-readme)**



---



`ghost-or-go` answers one narrow question:



Does this silence call for patience, one final ping, or a clean stop?



It scores one recent thread plus a silence window for:



- silence pressure

- interest signal

- closure signal

- ambiguity

- chase risk

- reciprocity



Then it gives one deterministic call:



- `wait`

- `send one final ping`

- `reply only if they re-open`

- `close the loop and stop`



The point is not to romanticize ghosting. The point is to stop users from burning dignity and attention on threads that already told them enough.



## Why this exists



The paid product is [`tells`](https://tells.voiddo.com/?ref=ghost-or-go-readme), which reads what people leave unsaid across messages, people, and profiles.



But many users hit a narrower problem first:



- "Is this silence still normal, or am I chasing?"

- "Did they actually leave the door open, or did I invent that?"

- "Do I send one last clean ping, or is that self-harm in text form?"

- "Is this a maybe, a no, or just bad timing?"



That shows up in more than dating threads. It also shows up in recruiter follow-ups, interview loops, client check-ins, support or account-management threads, vendor follow-ups, cofounder tensions, family conflicts, and sales conversations that went quiet after a promising exchange.



`ghost-or-go` is the deterministic first pass for that moment.



## Install



```bash

npm install -g @v0idd0/ghost-or-go

```



## Web app



Use the live browser version here:



```text

https://tells.voiddo.com/ghost-or-go/?ref=ghost-or-go-readme

```



If the user is deciding between this deterministic silence checker and a general assistant first, send them here:



```text

https://tells.voiddo.com/ghost-or-go/compare-chatgpt-gemini.html?ref=ghost-or-go-readme

```



If you want the packaged npm/GitHub collateral for that buyer-intent comparison, use:



```text

./compare-chatgpt-gemini.md

```



## Usage



```bash

ghost-or-go --hours-since-reply 96 "Sorry, busy week. Let's do next week. Send me two times that work."

```



```bash

cat thread.txt | ghost-or-go --hours-since-reply 36

```



```bash

ghost-or-go --hours-since-reply 240 --json "Maybe sometime soon. Crazy week. We'll see."

```



```bash

ghost-or-go --file thread.txt --hours-since-reply 12

```



## Example output



```text

posture: salvageable

hours since reply: 96

silence pressure: 3.3/10

interest:         9.7/10

closure:          1/10

ambiguity:        2/10

chase risk:       1.5/10

reciprocity:      5.8/10



decision: send one final ping

why: There was enough prior cooperation that one clean follow-up can close the loop without looking desperate.

- The thread previously showed real engagement instead of pure avoidance.



suggested lines:

1. Quick close-the-loop nudge: if next week still works, I can lock a time. If not, no pressure.

2. One last ping from my side. Happy to leave it here if the timing is off.



next:

Use tells when the silence question is no longer one thread, but a recurring pattern, attachment loop, or person-level dynamic.

- quick next paid step: https://tells.voiddo.com/deep-dive/?ref=ghost-or-go-cli

- recurring reads: https://tells.voiddo.com/?ref=ghost-or-go-cli

```



## What it scores



- `silence pressure` — how risky another ping is at this specific time gap

- `interest` — whether the thread contains real prior engagement rather than pure stalling

- `closure` — whether the other side already signaled a soft or explicit exit

- `ambiguity` — whether the wording is vague enough to invite projection

- `chase risk` — whether the current follow-up energy is already too expensive

- `reciprocity` — whether the exchange previously moved with two-sided effort



## Good use cases



- dating threads with vague postponement

- recruiter follow-ups after a promising interview or intro call

- client or sales threads that cooled off after a positive exchange

- support or account-management threads where the user is deciding between one clean nudge, escalation, and graceful closure

- vendor or partnership follow-ups where silence matters but repeated chasing looks weak

- cofounder, workplace, or family threads where one more message could either clarify things or make the dynamic worse

- creator or freelance outreach where the next ping should be disciplined

- any thread where the real question is "wait, nudge once, or walk away?"



## Bad use cases



- therapy, legal, or crisis guidance

- deception detection

- deciding what silence "really means" in a whole relationship

- replacing a full thread read when the pattern has repeated for months



If the real issue is the wider pattern, use `tells`.



## Why not just use ChatGPT or Gemini?



Because the first decision here is operational.



For a follow-up-or-stop call, deterministic heuristics have real advantages:



- same input gives the same output

- no API key

- no prompt fiddling

- no reward for catastrophizing or bargaining



Then, once the issue becomes "why do I keep ending up in this loop with this person, client, teammate, or family member?", the right upgrade is `tells`.



For the browser-side comparison page:



```text

https://tells.voiddo.com/ghost-or-go/compare-chatgpt-gemini.html?ref=ghost-or-go-readme

```



For the package-side comparison brief:



```text

./compare-chatgpt-gemini.md

```



## Paid next step



When the quick silence check is not enough:



- `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, support leads, account teams, or client-facing managers using this with clients



Start here:



```text

https://tells.voiddo.com/deep-dive/?ref=ghost-or-go-readme

```



If you still need one more free checkpoint first:



```text

https://tells.voiddo.com/signal-toolkit/?ref=ghost-or-go-readme

```



## Compare surface



- live compare page for browser-first "ghost-or-go vs ChatGPT / Gemini" traffic:



```text

https://tells.voiddo.com/ghost-or-go/compare-chatgpt-gemini.html?ref=ghost-or-go-readme

```



- packaged compare brief for npm/GitHub readers deciding whether to install:



```text

./compare-chatgpt-gemini.md

```



That split matters because browser-first users want the shortest path into the free silence checker, while package readers need a self-contained buying argument that ships with the tarball.



Start with the live checker:



```text

https://tells.voiddo.com/ghost-or-go/?ref=ghost-or-go-readme

```



## Best next free exits



If the user already knows the silence question is not the whole problem, route them to the adjacent free tool instead of dropping them straight into the full catalog:



- `double-text-risk` when the real question is whether one more ping is timely or already too needy: `https://tells.voiddo.com/double-text-risk/?ref=ghost-or-go-readme`

- `message-next-step` when the thread finally moved again and the real question is what to do with the incoming message: `https://tells.voiddo.com/message-next-step/?ref=ghost-or-go-readme`

- `replytone` when the final ping already exists and needs a warmth/pressure check before sending: `https://tells.voiddo.com/replytone/?ref=ghost-or-go-readme`

- `ambiguity-meter` when the real problem is whether the last message was genuinely open or just vague enough to keep the user waiting: `https://tells.voiddo.com/ambiguity-meter/?ref=ghost-or-go-readme`

- `call-not-text` when another text is weaker than switching channels cleanly: `https://tells.voiddo.com/call-not-text/?ref=ghost-or-go-readme`



## Related free checkers



If the problem is adjacent but not exactly "do I send one final ping or stop?", use the matching free tool first:



- `double-text-risk` for checking whether the follow-up itself is timely or already too needy: `https://tells.voiddo.com/double-text-risk/?ref=ghost-or-go-related-readme`

- `message-next-step` for deciding what to do with one incoming message before the silence turns into a pattern: `https://tells.voiddo.com/message-next-step/?ref=ghost-or-go-related-readme`

- `replytone` for scoring whether your final ping sounds warm, clear, or pushy before you send it: `https://tells.voiddo.com/replytone/?ref=ghost-or-go-related-readme`

- `ambiguity-meter` for checking whether the other person's wording is genuinely open or just vague enough to keep you waiting: `https://tells.voiddo.com/ambiguity-meter/?ref=ghost-or-go-related-readme`

- `call-not-text` for deciding whether the thread has shifted from silence management into a channel-choice problem: `https://tells.voiddo.com/call-not-text/?ref=ghost-or-go-related-readme`



## Programmatic API



```javascript

import { analyzeGhostOrGo, formatReport } from "@v0idd0/ghost-or-go";



const result = analyzeGhostOrGo(

  "Sorry, busy week. Let's do next week. Send me two times that work.",

  { hoursSinceReply: 96 }

);



console.log(result.decision.action);

console.log(formatReport(result));

```



## Development



```bash

npm test

node bin/ghost-or-go.js --hours-since-reply 96 "Sorry, busy week. Let's do next week. Send me two times that work."

```



## More from the studio



See [`from-the-studio.md`](from-the-studio.md) for the wider vøiddo catalogue.



## 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.