TOC Skills

TOC Thinking Processes skills for AI agents.

TOC Skills helps an agent ask better questions, store the current truth of a case, map causality, distinguish necessity from sufficiency logic, surface hidden assumptions, draw conflict clouds, and turn a broken assumption into a candidate injection.

It is intentionally small and composable. The suite is not a giant TOC textbook in one prompt. Each skill owns one job, toc-thinking routes to exactly one tool skill per turn, and tool skills hand gaps back to the loop instead of loading each other.

Current architecture: toc-thinking routes the What to change? phase through a 12-stage current-reality path. Case truth stays Markdown-first under ~/.d-toc/, while toc-diagram writes schema-versioned data.json; a fixed global viewer renders that JSON on demand.

Install

Manual install for Codex-style skill folders:

git clone https://github.com/Dimon94/toc-skills.git
mkdir -p "${CODEX_HOME:-$HOME/.codex}/skills"
cp -R toc-skills/skills/toc-* "${CODEX_HOME:-$HOME/.codex}/skills/"

If your skill installer supports GitHub skill repos, install from:

npx skills@latest add Dimon94/toc-skills

Use

Start a case:

/toc-thinking

Draw the current map:

/toc-map

The main loop is:

1. read or create the local case and keep the active TOC question explicit
2. while answering What to change?, follow the 12-stage path: collect, clean, classify, connect, stitch, converge, verify, and hand off
3. resolve uncertain details evidence-first, then grill with one option-backed question at a time
4. store facts, hypotheses, assumptions, effects, conflicts, and decisions in one local CASE.md
5. verify candidate causes on the effect-cause-effect ladder: falsify first, corroborate, then confirm
6. analyze the Current Reality Tree, candidate constraints, hidden assumptions, and conflict clouds
7. review logic in order: clarity, existence, then sufficiency
8. record a candidate injection when it breaks a named assumption
9. write partial or complete data.json; the global viewer renders the available snapshots
10. ask the next highest-leverage question with candidate answers, recommended first

Skills

Human entry points

• toc-thinking - starts or continues a TOC case and orchestrates the full reasoning loop.
• toc-map - renders the current case through data.json and the global viewer without doing a full new analysis.

Model-invoked tools

• toc-theory - TOC / TP theory router and vocabulary source.
• toc-case-state - Markdown-first local truth source for the case.
• toc-intake - classifies raw material into facts, UDEs, judgments, assumptions, and conflicts.
• toc-ece - verifies candidate causes on the effect-cause-effect ladder: conjecture, falsify, corroborate, confirm.
• toc-grill - resolves open questions evidence-first, or asks the user one option-backed question per turn.
• toc-crt - builds the Current Reality Tree skeleton and owns the connection, convergence, placeholder, and loop stages.
• toc-constraint - tests whether a candidate constraint really limits the system goal.
• toc-cloud - builds an Evaporating Cloud / Conflict Resolution Diagram.
• toc-injection - records candidate injections that break named assumptions.
• toc-assumption - extracts and challenges assumptions behind arrows and conflicts.
• toc-reservation - applies Categories of Legitimate Reservation to weak logic.
• toc-diagram - writes data.json for the case map; the global viewer renders six template types across a seven-stage rail.

Case Truth

Case truth is local and Markdown-first. The default shape is:

~/.d-toc/<slug>-<hash8>/
  PROJECT.md
  ACTIVE_CASE
  views/
    index.html         # symlink to ~/.d-toc/viewer/index.html
    data.json          # current active-case view data
    solution/          # only when a real solution-trail artifact exists
      index.html       # symlink to the same fixed viewer
      data.json        # current solution-trail view data
    archive/
      <case-id>/
        index.html     # symlink to ~/.d-toc/viewer/index.html
        data.json      # closed-case final view data
        solution/      # only when the active case had a solution artifact
          index.html   # symlink to the same fixed viewer
          data.json    # archived trail with recorded status unchanged
  cases/
    <case-id>/
      CASE.md
      DECISIONS/

ACTIVE_CASE stores the one active case ID for the project. A new chat session resumes that case; a new case is created only after the active case is closed, archived, or explicitly superseded by a changed system boundary, goal, or target UDE cluster.

CASE.md is the fact and current-thinking file. It stores Current, Source Material, Facts, Logic Under Test, Thinking Aids, and Open Questions. It must not become a chat record or timeline journal. Decision files under DECISIONS/ use ADR-style numbering and are updated by topic.

views/data.json is the current active-case visualization data (schema docs/data-json-schema.md, version "1.0"). It drives six template types (collect, check-table, classification-board, crt-graph, pipeline, ece-branch) across the seven-stage rail (collect, check, classify, connect, stitch, verify, final). A real solution trail stays separate at views/solution/data.json; the two views use fixed relative links and the same global viewer. When a case closes, archive the current-state view and copy the paired solution view only if that artifact exists. Archive copies recorded trail status exactly, including blocked, and never creates an empty solution view.

At 390x844 the solution trail becomes a collapsible audit dossier: the candidate-only warning stays visible, route trace scrolling remains local, B/C coverage stays separate and stacks vertically, and the page has no horizontal overflow.

The solution trail uses one ownership vocabulary across skills and data. toc-assumption owns four-route challenge work, toc-injection owns candidate packages, coverage, gates, and dispositions, toc-case-state owns pointers and status-faithful archives, toc-diagram projects recorded truth, and toc-thinking owns the human-authority boundary. A trail may become decision_ready only when at least one retained package independently passes, every considered branch and package has a disposition, the retained path has no open blocker, and one concrete next-validation question is recorded. It still displays candidate with effect and negative-branch validation not_completed; no later validation or planning starts without a separate explicit human commitment.

Early cases may write partial snapshots. A complete map is written only after enough interrogation has clarified the goal, current or candidate constraint, main causality, key assumptions, open blockers, and handoff to solution discussion.

Temporary thinking-aid diagrams live under $TMPDIR/d-toc/<project-folder>/<case-id>/thinking-aids/.

Current Scope

V1 focuses on What to change? and the first safe step into What to change to?

Included:

• evidence-first, option-backed grilling
• 12-stage current-reality routing
• current reality analysis
• Current Reality Tree skeletons
• effect-cause-effect hypothesis verification
• assumption tracking
• necessity vs sufficiency logic checks
• candidate constraint testing
• conflict cloud drafting
• candidate injection records
• reservation-based review
• temporary thinking aids
• partial and complete data.json maps rendered by the fixed global viewer

Planned later:

• Future Reality Tree
• Negative Branch Reservations
• Prerequisite Tree
• Transition Tree
• Strategy and Tactic Tree
• Drum-Buffer-Rope
• Critical Chain Project Management
• Throughput Accounting

See docs/toc-suite/ROADMAP.md.

Validate

npm test

The validator checks that the repo contains only the expected TOC skills, that frontmatter names match directory names, that human entry skills are marked user-invoked, and that required TOC docs are present.

It also checks the JSON-output contract, global case-library anchors, and stale contract phrases that would pull the suite back to older storage or HTML-output models.

The same command verifies that the package version and changelog history are consistent and that the required release files are present.

Versioning and releases

TOC Skills follows Semantic Versioning and Keep a Changelog. package.json records the current released version, CHANGELOG.md records released and unreleased changes, and version tags drive GitHub Releases.

Maintainers should add observable changes to Unreleased as part of the same change. The release procedure and version commands are documented in RELEASING.md.

License

MIT