← Back to Skills Marketplace
shaoqing404

Dont Deal Triage

by 少卿 · GitHub ↗ · v0.1.0 · MIT-0
cross-platform ⚠ suspicious
92
Downloads
0
Stars
0
Active Installs
1
Versions
Install in OpenClaw
/install dont-deal-triage
Description
Use this skill when a developer or desk worker reports chest pain, chest pressure, left arm or jaw discomfort, shortness of breath, unusual sweating, faintne...
README (SKILL.md)

dont-deal-triage

This skill is for conservative, local-first support. It is not a diagnosis skill.

Workflow

  1. Gather local context before reasoning. This skill package is self-contained. From the skill folder, run node scripts/index.js to generate the latest local snapshot. If command execution is unavailable, read ~/.dont-deal/snapshot.json if it already exists.

  2. In quick mode, solve only the red vs yellow question. Read references/quick-mode.md. The core output is: red = emergency help now yellow = urgent medical review today

  3. Check for immediate red flags before asking many questions. Read references/emergency-thresholds.md. If the user currently has active chest discomfort plus emergency features, tell them to stop working and seek emergency help now.

  4. Use fatigue data as context, not proof. Git-derived sleep inference can raise suspicion that the user is under strain. It cannot rule heart risk in or out.

  5. Keep the conversation short and action-oriented. If the user is symptomatic right now, prefer one question at a time. Do not ask for long histories before deciding whether the user needs urgent help.

  6. Persist only local summaries. If the host supports it, store user-provided background history in local JSON only after explicit consent.

  7. Keep machine inspection narrow. Detect only the current host context. Read only the active repository's git timestamps. Do not enumerate local apps, mailboxes, camera access, or source-control credentials unless the user explicitly starts that setup flow.

  8. Treat bystander use as valid. The user may be asking for someone else. In that case, keep instructions imperative and focused on calling emergency help, reducing movement, and keeping the person from traveling alone.

  9. Prefer the bundled scripts over ad hoc reimplementation. Use scripts/quick-triage-cli.js for local fast-mode testing. Use scripts/index.js for the local fatigue and host snapshot.

Response rules

  • Never reassure the user that symptoms are "just stress" or "probably not serious."
  • Never tell the user to drive themselves to the hospital when emergency symptoms are active.
  • Tell the user to reduce activity immediately if chest pain is ongoing.
  • If emergency care is indicated, stop discussing code or work until the user confirms they are safe.
  • Treat git activity as a weak fatigue signal, not evidence about the user's exact sleep duration.
  • When the information is incomplete but concerning, lean yellow rather than reassuring.
  • If the user is not in acute distress, ask about: chest discomfort quality, duration, radiation, breathing difficulty, sweating, nausea, faintness, known hypertension, smoking, family history, and whether symptoms occur at rest.

Output shape

When the host can return structure, prefer:

{
  "urgency": "emergency | urgent | monitor",
  "reasoning_summary": [
    "Current symptoms",
    "Fatigue context",
    "Known risk factors"
  ],
  "recommended_action": "short imperative sentence",
  "follow_up_questions": []
}

Host portability

Keep this skill prompt generic:

  • Claude Code can wire this through its own skill surface.
  • Codex can invoke the local analyzer directly.
  • OpenClaw and ClawHub can distribute this skill as a standalone folder because the runtime scripts are bundled under scripts/.

Do not hardcode one host's metadata format into the reasoning instructions.

Usage Guidance
This skill appears to do what it says: run locally, read git commit timestamps to estimate recent sleep/fatigue, inspect basic system/time/parent-process info, interactively ask triage questions, and save structured results under ~/.dont-deal. Before installing or running: - Review the code if you want to confirm there are no network calls (none are present). - Be aware it executes local commands (git and ps) and walks parent directories to find a git repo — run it from a directory whose repo you are comfortable having examined. - The skill writes local files (snapshot.json, profile.json, events.json, config.json). If you require explicit consent before storing anything, step through the quick-triage flow and confirm when/what it writes; you can set DONT_DEAL_HOME to control the storage location. - No credentials are required and the code does not transmit data externally, but the host-detection logic checks for presence of common API key env vars (it only reads them to infer the host). If you need stricter privacy, run the scripts in a controlled environment or set DONT_DEAL_HOME to a directory you control; otherwise this bundle is internally consistent with its stated purpose.
Capability Analysis
Type: OpenClaw Skill Name: dont-deal-triage Version: 0.1.0 The skill bundle is a medical triage tool for developers that assesses chest pain symptoms while factoring in fatigue derived from local git commit history. It uses 'child_process.execFile' to run 'git log' and 'ps' for environment detection, and it stores user-provided health data and triage results locally in '~/.dont-deal/'. While it identifies the presence of sensitive environment variables (e.g., ANTHROPIC_API_KEY) to determine the host environment, it does not record their values or exfiltrate any data to external endpoints.
Capability Assessment
Purpose & Capability
Name/description ask for conservative, local-first triage and the code implements that: git-derived fatigue inference, local system/host detection, interactive quick-triage CLI, and local JSON storage. The host-detection code inspects environment variables to guess the runtime host (e.g., OPENAI_API_KEY, ANTHROPIC_API_KEY) but only to label the host — this is plausible for UI/telemetry and does not itself require credentials.
Instruction Scope
SKILL.md instructs the runtime to run bundled scripts/index.js or quick-triage CLI. The scripts run local commands (git, ps) to read git commit timestamps and parent process info, read/write local JSON under the user's home (~/.dont-deal), and interactively ask questions. There are no instructions or code paths that contact remote endpoints or exfiltrate data. Note: the code climbs parent directories to find the nearest .git, so it will examine the nearest repository from the current working directory upward — users should be aware of which repo the skill will inspect.
Install Mechanism
No external install or downloads are specified. The skill is a bundled Node package with local scripts and a package.json (usable for running the scripts). No remote URLs, package installs, or extracted archives are used.
Credentials
The skill declares no required env vars or credentials. At runtime it reads process.env to (a) allow DONT_DEAL_HOME override and (b) heuristically detect hosting environments by checking for keys like OPENAI_API_KEY, ANTHROPIC_API_KEY, OPENCLAW, and other host signals. Reading env to detect host is proportionate to its UI/telemetry goal, but users should note that the presence of API key variables is checked (not transmitted). No secret is sent out by the code.
Persistence & Privilege
The skill persists data under ~./dont-deal (snapshot.json, profile.json, events.json, config.json). SKILL.md states to persist user-provided background history only after explicit consent; the code will create a default config and the quick CLI appears to write events/profile locally. Users should verify the interactive flow creates stored records only after consent if that is a requirement for them. There is no evidence the skill modifies other skills or system-wide settings.
How to Use
  1. Make sure OpenClaw is installed (local or Docker)
  2. Run the install command in chat: /install dont-deal-triage
  3. After installation, invoke the skill by name or use /dont-deal-triage
  4. Provide required inputs per the skill's parameter spec and get structured output
Version History
v0.1.0
dont-deal-triage 0.1.0 – Initial release - Provides conservative, local-first triage for chest pain or exhaustion reports among developers and desk workers. - Implements fast "red vs yellow" decision flow for emergency vs urgent response. - Integrates local context via host and git activity snapshot, prioritizing current symptoms. - Enforces privacy: reads only local git and host state; persists user history only with consent. - Maintains short, action-oriented conversations focused on safety, avoiding reassurance or long histories in emergencies. - Supports bystander use; includes clear, imperative instructions for emergency action.
Metadata
Slug dont-deal-triage
Version 0.1.0
License MIT-0
All-time Installs 0
Active Installs 0
Total Versions 1
Frequently Asked Questions

What is Dont Deal Triage?

Use this skill when a developer or desk worker reports chest pain, chest pressure, left arm or jaw discomfort, shortness of breath, unusual sweating, faintne... It is an AI Agent Skill for Claude Code / OpenClaw, with 92 downloads so far.

How do I install Dont Deal Triage?

Run "/install dont-deal-triage" in the OpenClaw or Claude Code chat to install it in one step — no extra setup required.

Is Dont Deal Triage free?

Yes, Dont Deal Triage is completely free, licensed under MIT-0. You can download, install and use it at no cost.

Which platforms does Dont Deal Triage support?

Dont Deal Triage is cross-platform and runs anywhere OpenClaw / Claude Code is available (cross-platform).

Who created Dont Deal Triage?

It is built and maintained by 少卿 (@shaoqing404); the current version is v0.1.0.

💬 Comments