Decision Logger logo

Decision Logger

Community
borghei
decision-logger

Two-layer memory for executive decisions, separating raw deliberation from approved decisions to prevent hallucinated consensus. Use when logging decisions, reviewing past decisions, or checking overdue action items.

Overview

Publisherborghei
RepositoryClaude-Skills
Skill namedecision-logger
Stars
856
Forks
154
Bundled files
3
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.

  • 3 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by borghei on GitHub. Read the source before you install it.

Installation

Install the Decision Logger 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/borghei/Claude-Skills/tree/main/c-level-advisor/decision-logger
  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/borghei/Claude-Skills.git /tmp/Claude-Skills
mkdir -p .claude/skills
cp -r /tmp/Claude-Skills/c-level-advisor/decision-logger .claude/skills/decision-logger
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Decision Logger 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 Decision Logger 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 Decision Logger 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.

Decision Logger

Two-layer memory system for executive decisions. Layer 1 stores everything discussed. Layer 2 stores only what the founder approved. Future sessions read Layer 2 only -- this prevents hallucinated consensus from past debates bleeding into new deliberations.

Keywords

decision log, memory, approved decisions, action items, board minutes, conflict detection, DO_NOT_RESURFACE, decision history, overdue, supersession, decision search, decision tracking, accountability


Two-Layer Architecture

Why Two Layers?

Single-layer decision logs create a dangerous problem: agents read old debates, rejected proposals, and discarded ideas, then treat them as context for new decisions. This causes "hallucinated consensus" where rejected ideas gradually become accepted through repetition.

The two-layer system prevents this by strictly separating raw discussion from approved decisions.

Layer Architecture

Layer 1: Raw Transcripts (NEVER auto-loaded)
  Location: memory/board-meetings/YYYY-MM-DD-raw.md
  Contains: Full deliberation, all perspectives, rejected arguments
  Loaded: Only on explicit founder request
  Retention: Active 90 days, then archived

Layer 2: Approved Decisions (AUTO-LOADED every session)
  Location: memory/board-meetings/decisions.md
  Contains: Only founder-approved decisions and action items
  Loaded: Automatically at start of every board meeting (Phase 1)
  Mutation: Append-only. Decisions are never deleted, only superseded.

Layer Interaction Rules

RuleRationale
Layer 2 is append-onlyPreserves complete decision history
Layer 1 is never auto-loadedPrevents hallucinated consensus
Only Chief of Staff writes to Layer 2Single point of control
Agents never write directlyAll writes go through Chief of Staff after founder approval
Superseded decisions stay in Layer 2History is the record; nothing is deleted

Decision Entry Format

Standard Decision Record

markdown
## [YYYY-MM-DD] -- [DECISION TITLE]

**Decision:** [One clear statement of what was decided]
**Context:** [1-2 sentences on why this decision was needed]
**Owner:** [One person or role accountable for execution]
**Deadline:** [YYYY-MM-DD]
**Review Date:** [YYYY-MM-DD]
**Confidence:** [High / Medium / Low]
**Rationale:** [Why this option over alternatives, 1-2 sentences]

**User Override:** [If founder changed agent recommendation -- what and why]

**Rejected Alternatives:**
- [Proposal] -- [reason for rejection] [DO_NOT_RESURFACE]
- [Proposal] -- [reason for rejection]

**Action Items:**
- [ ] [Action] -- Owner: [name] -- Due: [YYYY-MM-DD]
- [ ] [Action] -- Owner: [name] -- Due: [YYYY-MM-DD]

**Dependencies:** [Other decisions this depends on]
**Supersedes:** [DATE of previous decision on same topic, if any]
**Superseded by:** [Filled retroactively if overridden later]
**Raw transcript:** memory/board-meetings/[DATE]-raw.md
**Tags:** [topic tags for search -- e.g., pricing, hiring, market-entry]

Completed Action Item Format

markdown
- [x] [Action] -- Owner: [name] -- Completed: [YYYY-MM-DD] -- Result: [one sentence]

Conflict Detection System

Before logging any new decision, the system checks for three types of conflicts.

Conflict Type 1: DO_NOT_RESURFACE Violation

A new decision matches a previously rejected proposal.

Detection: New proposal text similarity > 70% to a rejected proposal

Response:
  BLOCKED: "[Proposal]" was rejected on [DATE].
  Reason: [original rejection reason]

  To reopen: Founder must explicitly say "reopen [topic] from [DATE]"
  This cannot be overridden by agents.

Conflict Type 2: Topic Contradiction

Two active decisions on the same topic reach different conclusions.

Detection: Same tags + contradictory conclusions

Response:
  DECISION CONFLICT DETECTED

  Active decision (older): [DATE] -- [decision text]
  New decision: [DATE] -- [decision text]

  These decisions contradict each other.

  Options:
  1. Supersede old decision (new replaces old)
  2. Merge decisions (reconcile the conflict)
  3. Defer to founder (present both, let founder choose)

Conflict Type 3: Owner Conflict

Same action assigned to different people in different decisions.

Detection: Same action description, different owners

Response:
  OWNER CONFLICT

  Action: "[action text]"
  Decision 1 ([DATE]): Owner = [Person A]
  Decision 2 ([DATE]): Owner = [Person B]

  Resolve: Which owner is correct?

Conflict Resolution Decision Tree

START: Conflict detected
  |
  v
[What type of conflict?]
  |
  +-- DO_NOT_RESURFACE --> Block automatically. Only founder can reopen.
  |
  +-- Topic contradiction --> [Is the new decision from a board meeting?]
  |                           |
  |                           +-- YES --> Supersede old by default (board > individual)
  |                           +-- NO  --> Present both to founder for resolution
  |
  +-- Owner conflict --> [Which decision is more recent?]
                         |
                         +-- Flag to founder with both dates
                         +-- Default to more recent unless founder overrides

Decision Lifecycle

States

PROPOSED --> APPROVED --> ACTIVE --> [COMPLETED | SUPERSEDED | EXPIRED]

PROPOSED:    Agent synthesis presented to founder
APPROVED:    Founder explicitly approved
ACTIVE:      Being executed, action items in progress
COMPLETED:   All action items done, review confirmed success
SUPERSEDED:  New decision replaced this one
EXPIRED:     Review date passed without renewal

State Transitions

FromToTriggerWho
ProposedApprovedFounder says "yes" or "approve"Founder
ProposedRejectedFounder says "no" or "reject"Founder
ApprovedActiveAction items begin executionAutomatic
ActiveCompletedAll action items marked doneChief of Staff
ActiveSupersededNew decision on same topicChief of Staff
ActiveExpiredReview date passed, no renewalSystem alert

Clarify First

Before logging a decision, confirm these inputs. If any is unknown or vague, ASK — do not assume:

  • The exact decision statement (one clear sentence of what was decided) — this is the heart of the record; a vague statement makes the log useless for future conflict detection
  • Owner and deadline — every decision record needs a single accountable person and a date, or it cannot be tracked or surfaced as overdue
  • Rejected alternatives and why — these become DO_NOT_RESURFACE entries that prevent rejected ideas from re-entering future deliberations
  • Whether this supersedes a prior decision on the same topic — drives conflict detection and supersession tracking against the existing log

Stop rule: ask only the 2-3 that most change the output. If the user says "just draft it," proceed and list your assumptions at the top of the artifact.

Logging Workflow

Post-Decision Logging (after Board Meeting Phase 5)

Step 1: Founder approves synthesis
  |
Step 2: Write Layer 1 raw transcript
  --> memory/board-meetings/YYYY-MM-DD-raw.md
  |
Step 3: Run conflict detection against decisions.md
  |
  +-- Conflicts found --> Surface to founder, wait for resolution
  +-- No conflicts --> Continue
  |
Step 4: Append approved entries to decisions.md (Layer 2)
  |
Step 5: Set review dates and action item deadlines
  |
Step 6: Confirm to founder:
  "Logged: [N] decisions, [M] action items tracked, [K] flags added"

Action Item Management

Overdue Detection

At the start of every session, scan for:

  1. Action items past their deadline
  2. Decisions with review dates that have passed
  3. Decisions older than 90 days with no completion status

Alert Format

OVERDUE ITEMS (as of [today's date])

Action Items Past Deadline:
  1. [Action] -- Owner: [name] -- Due: [date] -- [X] days overdue
     From decision: [decision title] ([date])

  2. [Action] -- Owner: [name] -- Due: [date] -- [X] days overdue

Decisions Pending Review:
  1. [Decision title] -- Review was due: [date]
     Original decision: [summary]
     Prompt: "You decided [X] on [date]. Worth a check-in?"

Stale Decisions (> 90 days, no status update):
  1. [Decision title] -- Decided: [date] -- Last update: [date]

Action Item Priority Matrix

UrgencyImpactPriorityResponse
OverdueHighCriticalEscalate to founder immediately
OverdueLowHighFlag in next session
Due this weekHighHighSurface proactively
Due this weekLowMediumInclude in weekly summary
Due next monthAnyLowMonitor only

Search and Retrieval

Search Capabilities

Query TypeExampleReturns
By topic"pricing"All decisions tagged with pricing
By owner"CTO"All decisions and actions owned by CTO
By date range"Q4 2025"All decisions from Oct-Dec 2025
By status"overdue"All overdue action items
By conflict"conflicts"All detected contradictions
By tag"hiring AND engineering"Intersection of tags

Decision Summary Views

ViewContentsWhen Used
Last 10Most recent 10 approved decisionsDefault quick view
Full historyAll decisions, chronologicalAudit or deep review
By ownerGrouped by accountable personAccountability check
By topicGrouped by tagStrategic review
Overdue onlyOnly overdue itemsAction management
Active onlyOnly decisions with open action itemsExecution tracking

File Structure

memory/
  board-meetings/
    decisions.md           # Layer 2: append-only, founder-approved
    YYYY-MM-DD-raw.md      # Layer 1: full transcript per meeting
    archive/
      YYYY/                # Raw transcripts after 90 days

Integration with Other Skills

SkillIntegration Point
Chief of Staff (chief-of-staff)Manages the logging workflow, writes to Layer 2
Board Meeting (board-meeting)Triggers logging after Phase 5 approval
Strategic Alignment (strategic-alignment)Checks if decisions cascade properly to team goals
Executive Mentor (executive-mentor)Reviews stale decisions for re-evaluation
Org Health (org-health-diagnostic)Decision velocity as health indicator

Red Flags

  • Same topic discussed 3+ times without a logged decision -- decision avoidance
  • Action items consistently overdue by the same owner -- capacity or accountability issue
  • Decisions made without checking history -- risk of contradiction
  • Layer 1 being loaded without explicit request -- hallucinated consensus risk
  • No review dates set on decisions -- decisions age without re-evaluation
  • Rejected proposals resurfacing in new language -- DO_NOT_RESURFACE not enforced
  • Decision log not consulted at start of board meetings -- institutional memory not used
  • All decisions owned by one person -- bottleneck or delegation failure

Proactive Triggers

  • Review date passed on a decision -- prompt: "You decided [X] on [date]. Worth checking in?"
  • Action item overdue > 7 days -- escalate to founder with owner context
  • Same topic area has 3+ active decisions -- consolidation review needed
  • 30+ days without any logged decision -- is the system being used?
  • New decision proposed that matches DO_NOT_RESURFACE -- block and explain
  • Decision from 6+ months ago with no status update -- mark as stale, prompt review

Output Artifacts

RequestDeliverable
"Show recent decisions"Last 10 approved decisions with status
"What's overdue?"All overdue action items with owner and days past due
"Search decisions about [topic]"Filtered decision history by topic/tag
"Log this decision"Formatted decision entry with all fields
"Check for conflicts"Conflict scan against all active decisions
"Decision summary for board"Decision velocity, completion rate, open items

Tool Reference

1. decision_tracker.py

Tracks executive decisions with full lifecycle management (Proposed > Approved > Active > Completed/Superseded/Expired). Scans for overdue action items, stale decisions, and generates status summaries.

bash
python scripts/decision_tracker.py --input decisions.json --json
python scripts/decision_tracker.py --input decisions.json
FlagTypeDescription
--inputrequiredPath to JSON file with decision records (title, status, owner, deadline, action items, tags)
--jsonoptionalOutput in JSON format instead of human-readable text

2. decision_quality_scorer.py

Scores decision quality across 6 dimensions: framing (problem definition), alternatives (options considered), information (evidence quality), reasoning (logic soundness), commitment (action clarity), and metacognition (awareness of uncertainty). Generates improvement recommendations.

bash
python scripts/decision_quality_scorer.py --input decision_assessments.json --json
python scripts/decision_quality_scorer.py --input decision_assessments.json
FlagTypeDescription
--inputrequiredPath to JSON file with decision assessments (dimension scores 1-10, optional outcome data)
--jsonoptionalOutput in JSON format instead of human-readable text

3. decision_tree_builder.py

Builds decision trees with expected value analysis. Calculates optimal paths through probability-weighted outcomes, identifies highest-value decisions, and generates sensitivity analysis on key assumptions.

bash
python scripts/decision_tree_builder.py --input tree_data.json --json
python scripts/decision_tree_builder.py --input tree_data.json
FlagTypeDescription
--inputrequiredPath to JSON file with decision nodes (options, probabilities, outcomes, values)
--jsonoptionalOutput in JSON format instead of human-readable text

Troubleshooting

ProblemLikely CauseResolution
Same topic discussed 3+ times without a logged decisionDecision avoidance or no clear decision-making authorityForce a decision at next session; use decision tree builder to clarify options; assign explicit decision owner
Action items consistently overdue by same ownerOwner over-committed, lacks capacity, or accountability issueReview owner workload; redistribute if capacity issue; escalate to founder if accountability issue
Decisions made without checking historyDecision log not consulted at session start; no integration habitAutomate decision log loading at board meeting Phase 1; surface relevant past decisions proactively
Rejected proposals resurfacing in new languageDO_NOT_RESURFACE not enforced; team members unaware of prior rejectionEnforce conflict detection before logging; block proposals matching rejected items; require explicit "reopen" from founder
Decision log growing but never consulted for patternsLog treated as archive, not strategic toolRun quarterly decision review; analyze decision velocity, completion rate, and quality trends
All decisions owned by one personBottleneck or delegation failureDistribute ownership; use decision quality scorer to assess whether centralization improves or hurts quality
Decision quality scores low on "alternatives" dimensionTeam anchoring on first option instead of exploringRequire minimum 3 alternatives for decisions above a threshold; use decision tree builder to model options

Success Criteria

  • All board meeting decisions logged in Layer 2 within 24 hours of approval
  • Action item completion rate exceeds 80% within stated deadlines
  • Zero DO_NOT_RESURFACE violations (rejected proposals do not re-enter decision flow)
  • Decision review dates honored for 90%+ of active decisions
  • Decision quality score averages above 7/10 across all 6 dimensions
  • Conflict detection catches 100% of topic contradictions before new decisions are logged
  • Decision log consulted at the start of every board meeting session

Scope & Limitations

In scope: Two-layer decision memory architecture, decision entry and lifecycle management (Proposed > Approved > Active > Completed/Superseded/Expired), conflict detection (DO_NOT_RESURFACE, topic contradiction, owner conflict), action item tracking with overdue alerting, decision search and retrieval by topic/owner/date/status, decision quality scoring, and expected value analysis via decision trees.

Out of scope: CRM or project management tool integration (tools consume JSON exports), meeting transcription or recording, team-level task management (use project-management/ skills), strategic planning or OKR tracking (use strategic-alignment or ceo-advisor), and automated decision-making. This skill tracks and evaluates decisions; it does not make them.

Limitations: Conflict detection uses tag and text matching; semantically similar but differently worded proposals may not be caught. Decision quality scoring is retrospective and depends on honest self-assessment. Decision tree expected value calculations assume probabilities are estimable; highly uncertain environments may make probability assignment misleading. The two-layer architecture requires discipline to maintain; if Layer 2 is not consistently updated, institutional memory degrades.


Integration Points

  • chief-of-staff -- Manages the logging workflow; single point of control for Layer 2 writes
  • board-meeting -- Triggers decision logging after Phase 5 approval; decision log loaded at Phase 1
  • strategic-alignment -- Checks if decisions cascade properly to team goals and OKRs
  • executive-mentor -- Reviews stale decisions for re-evaluation; coaches on decision quality improvement
  • ceo-advisor -- Strategic decisions logged and tracked; decision patterns inform leadership coaching

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Decision Logger AI skill do?

Two-layer memory for executive decisions, separating raw deliberation from approved decisions to prevent hallucinated consensus. Use when logging decisions, reviewing past decisions, or checking overdue action items.

Why use Decision Logger on TypingMind?

Because you install it once and use it with any model. Decision Logger 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 Decision Logger in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/borghei/Claude-Skills/tree/main/c-level-advisor/decision-logger. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Decision Logger?

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 Decision Logger?

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

Is the Decision Logger AI skill free?

It is published on GitHub by borghei. Check the repository for licensing terms. 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 👇