Relations logo

Relations

Organization
Lifecycle-Innovations-Limited
relations

OPS on-demand: This skill should be used when the user asks to "who do I owe a reply", "relationship…

Overview

PublisherLifecycle-Innovations-Limited
Repositoryclaude-ops
Skill namerelations
Stars
543
Forks
64
Bundled files
Instructions only
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by Lifecycle-Innovations-Limited on GitHub. Read the source before you install it.

Installation

Install the Relations AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/Lifecycle-Innovations-Limited/claude-ops/tree/main/claude-ops/skills/relations
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/Lifecycle-Innovations-Limited/claude-ops.git /tmp/claude-ops
mkdir -p .claude/skills
cp -r /tmp/claude-ops/claude-ops/skills/relations .claude/skills/relations
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Relations in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Relations on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Relations is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

/ops:relations — Relationship Manager

Load ops-rules before acting. Public repo (no personal data). Outbound: one draft → one approval → one send. If AskUserQuestion / Workflow are missing, follow Rule 10 in ops-rules (Hermes: numbered options / two-turn Telegram card; delegate_task).

Relationship ledger and decision queue. Answers: who is owed a reply, what was promised, what is going cold, and what context a draft needs before it is written. It never sends anything.

Configuration

Every path and toggle comes from plugin userConfig, an env var, or $HOME. Nothing in this skill is machine-specific.

userConfig keyEnv overrideDefaultMeaning
relations_cliRELATIONS_CLI$HOME/.claude-ops/relations/bin/relations-cliLedger CLI entry point (JSON out)
relations_db_pathRELATIONS_DB$HOME/.claude-ops/relations/people.dbSQLite ledger, the factual source of truth
relations_shadow_modeRELATIONS_SHADOW_MODEtrueWhen true, no external send on any channel
relations_queue_limitRELATIONS_QUEUE_LIMIT10Max decision-queue items per report
relations_followup_limit_personal—1Unanswered follow-ups allowed, personal
relations_followup_limit_business—2Unanswered follow-ups allowed, business
relations_suppress_days—30Minimum suppression after a dismissal

Resolve in this order, first non-empty wins. Never hardcode an absolute path:

bash
PREFS_PATH="${PREFS_PATH:-${CLAUDE_PLUGIN_DATA_DIR:-$HOME/.claude/plugins/data/ops-ops-marketplace}/preferences.json}"
read_pref() { [ -f "$PREFS_PATH" ] && python3 -c 'import json,sys;print(json.load(open(sys.argv[1])).get(sys.argv[2],"") or "")' "$PREFS_PATH" "$1" 2>/dev/null; }

RELATIONS_CLI="${RELATIONS_CLI:-$(read_pref relations_cli)}"
RELATIONS_CLI="${RELATIONS_CLI:-$HOME/.claude-ops/relations/bin/relations-cli}"
RELATIONS_DB="${RELATIONS_DB:-$(read_pref relations_db_path)}"
RELATIONS_DB="${RELATIONS_DB:-$HOME/.claude-ops/relations/people.db}"

if [ ! -x "$RELATIONS_CLI" ]; then
  echo "relations: no ledger CLI at $RELATIONS_CLI — set userConfig relations_cli or RELATIONS_CLI" >&2
fi

A missing CLI is reported as a missing CLI. Never fall back to an empty result: "no follow-ups" and "the ledger is not installed" must never look the same.

Hard rules

  1. Shadow mode is the default. With relations_shadow_mode true, this skill drafts and stages only. No email, chat, SMS, or calendar invite leaves the box.
  2. Never merge two records on a name. Hard keys only: contact-provider id, normalized email, E.164 phone, or a previously verified alias. Everything else goes to the review queue.
  3. Every fact, commitment and follow-up carries a source reference. No source, no row, no draft sentence.
  4. Facts and inference are separate. An inference never justifies an outbound.
  5. Silence is the default. Nothing meaningful changed means send nothing.
  6. Contact history never enters agent memory. Person facts belong in the ledger DB, not in a memory plane or a committed file. See ops-rules Rule 0.
  7. Progressive disclosure. Never load the contact list into context. Query the one person you need.

Operations

SubcommandWhat it does
queue (default)Ranked decision queue, max relations_queue_limit, one per person
brief <person>Contact methods, open commitments, sourced facts, recent threads
find <key>Resolve an identity by email / phone / name; ambiguity → review
draft <person>Full-context draft, staged for approval, never sent
close <id>Close a follow-up with a reason
snooze <id> <ts>Defer with a reason
suppress <id>Dismiss for at least relations_suppress_days
auditDuplicates, unsourced rows, stale facts, integrity
bash
"$RELATIONS_CLI" queue --limit "${RELATIONS_QUEUE_LIMIT:-10}"
"$RELATIONS_CLI" brief <person_id>
"$RELATIONS_CLI" find --email user@example.com
"$RELATIONS_CLI" close <follow_up_id> --reason "they replied on chat"

Draft order (fixed)

  1. Resolve identity across every channel the person owns — never answer on one channel while the real conversation is on another.
  2. Read the COMPLETE thread, not the latest message. Check both directions (sent and received) and every account the channel has.
  3. Read messages from the recipient and anyone relevant on copy.
  4. Check the calendar and open commitments.
  5. Check vip tier first (see the vip skill) — a tier-1 person is drafted with more care and never batched into a digest.
  6. Load humanizer, write ONE draft in the owner's voice, in the language the thread is already in.
  7. Stage it for approval with recipient, channel, thread, and a content hash. If any of those change, ask again. Send only the exact approved content.

Never send. Never produce several near-duplicate drafts.

Follow-up gate

States: i_owe_them, they_owe_me, waiting_date, waiting_document, waiting_decision, going_cold, no_action, suppressed.

The gate blocks on: do-not-automate, archived person, snoozed, suppressed, not due yet, they responded elsewhere, upcoming meeting, unanswered limit (relations_followup_limit_personal / _business), missing source reference, cross-channel duplicate.

Not every unanswered message is overdue. Was a response actually requested? Was something promised? Has that date arrived? Would silence be more natural?

Report format

Plain text, no decoration, recommendation first, max relations_queue_limit items, numbered actions per item. If nothing survives the gate, output nothing.

relationship desk — monday

1. <person>
business, a revised proposal was promised friday (email thread, <date>)
recommendation: send the prepared draft, confidence high

1 approve   2 edit   3 snooze 2 days   4 close   5 show context

Source authority

Current complete thread > verified identity > current calendar event > current conversation > signed document > this ledger > recent public primary source > search result > existing summary > draft. A draft is never a source of truth. On conflict: record it, prefer the newest authoritative primary source, surface it, and do not send until it is resolved.

Related skills

  • vip — who is checked and answered first; always consulted before triage
  • ops-inbox — channel sweeps feed this ledger
  • ops-comms — the send path, gated by Rule 6
  • people — contact directory sync (identity layer under this ledger)
  • humanizer — voice pass before any draft is staged
  • ops-rules — Rule 0 (public repo), Rule 6 (per-message approval)

Frequently asked questions

What does the Relations AI skill do?

OPS on-demand: This skill should be used when the user asks to "who do I owe a reply", "relationship…

Why use Relations on TypingMind?

Because you install it once and use it with any model. Relations is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Relations in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/Lifecycle-Innovations-Limited/claude-ops/tree/main/claude-ops/skills/relations. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Relations?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Relations?

As many as you like. As long as a model supports skills, you can use Relations with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Relations AI skill free?

Yes. It is published on GitHub by Lifecycle-Innovations-Limited under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇