thinqos-plugins

Official AI4Outcomes plugin marketplace for Claude Code and Codex.

thinqOS Mind plugin

Connects Claude Code and Codex to your persistent Mind, authorized resources and agents in thinqOS:

• Prime: reflexive memory recall injected at session start (and again after a compaction or /clear, when the host drops the conversation), then a short per-prompt lookup keyed on what you just asked.
• Resume: cross-machine "pick up where you left off" context at session start.
• Capture: every session is harvested into your Mind (final capture on Stop, crash-safe incremental capture mid-turn, debounced to at most one post per 90s). Both capture hooks detach before doing any network work, so latency never blocks a command or session shutdown on any host. See What gets captured for exactly what leaves your machine.
• Guardrails: kept lessons warn before matching tool calls; the anti-fabrication standing rule fires on every prompt.
• MCP: the thinqOS MCP tools (recall, remember, forget, check, advise, history, ask_agent, status, and the generic thinqos_query/thinqos_create/ thinqos_update/thinqos_delete/thinqos_action verbs that reach everything else).
• Operations: discover current resources with thinqos_query and describe=true, then use the matching authorized operation. Supported operations, permission, account setup and successful execution are separate facts.
• Consultation: use ask_agent to ask thinqOS Help or another reachable agent to do work using its own authorized capabilities and connections.
• Skill: thinqos:remembering, the shared operational and Mind contract for resource discovery, agent consultation and recall/advise/persist discipline.

Requirements

• A thinqOS account. This plugin is a thin client for the hosted thinqOS service: it supplies host configuration and does no work on its own. Without an account and an API key, thinqos install has nothing to connect to. Request access · Sign in · Pricing
• Python 3.13 or newer, and uv to install the CLI.
• Claude Code or Codex. Claude uses the plugin hooks. Codex uses the packaged thinqos:remembering skill while the CLI remains the single source for lifecycle hooks. Grok Build is supported by the CLI directly.

Install

1. Install the CLI (the plugin packages hooks; the CLI configures the MCP connection and does the work):

   uv tool install thinqos
   

2. Configure thinqOS for Claude Code. The CLI uses your existing authenticated thinqOS connection and installs one MCP registration:

   thinqos install --client claude
   

3. Add the marketplace and install the plugin. It supplies hooks only; it does not create a second MCP connection or prompt for a separate token:

   /plugin marketplace add AI4Outcomes/thinqos-plugins
   /plugin install thinqos@thinqos-plugins
   

4. Re-run the installer once after enabling the plugin. It detects the plugin and removes any settings-managed hook entries so nothing fires twice:

   thinqos install --client claude
   

Verify with thinqos doctor (thinqos_connectivity: pass and no double-wired hooks).

Codex

The official Codex plugin owns the MCP server and launches thinqos mcp serve. Codex selects the native package through .agents/plugins/marketplace.json; the portable remote-MCP package has a separate delivery path described below. The CLI uses your paired deployment and credential together and owns the native lifecycle hooks in ~/.codex/hooks.json.

Upgrade the CLI before installing plugin 0.4.4, then verify that its transport command is available:

uv tool upgrade thinqos
thinqos mcp serve --help
thinqos install --client codex

The installer installs the official plugin, removes the obsolete direct MCP registration, and preserves other servers. If hook commands changed, open Codex's /hooks screen and approve User config. Verify with thinqos doctor.

Claude's hook manifest lives under .claude-plugin/, outside Codex's default root hook discovery path. The runtime stand-down in the scripts remains as backward compatibility for Codex caches older than plugin 0.2.5.

ChatGPT delivery targets

A direct archive import containing mcp.json is desktop-only in ChatGPT, even when the server uses HTTPS. It does not make the tools available in ChatGPT web or mobile. Installing the CLI or a repository package does not publish a plugin in the OpenAI directory.

Web and mobile require a web-compatible plugin available to the account, plus access to its registered app and an authenticated thinqOS connection. Verify actual tools in a new chat before relying on recall or automatic capture. A ChatGPT memory notification is not a thinqOS persistence receipt. The remembering skill saves useful facts through available tools; it does not provide background access to all ChatGPT chats or a continuous transcript stream.

Build the correct archive

Run these commands from the canonical thinqos repository. Both exports include the canonical remembering skill and icon and refuse to overwrite an existing ZIP.

For OpenAI directory submission:

python tools/thinqos-plugin/build.py --export-openai /tmp/thinqos-directory.zip

This archive declares the remote MCP server. Complete connection, domain and tool checks in the publisher dashboard, then follow review and publication. A valid ZIP is not proof of approval, publication or working web tools. Directly importing this same ZIP as a personal plugin still makes it desktop-only.

For private web distribution referencing an existing registered app:

python tools/thinqos-plugin/build.py --export-private-web /tmp/thinqos-private-web.zip --app-id asdk_app_FROM_EXISTING_APP

Replace the example app ID with the actual existing registered app ID. This export contains an app reference instead of a direct MCP declaration or hooks. It creates no app, grants no access and does not authenticate the connection. The referenced app must already be available to the intended account. Use the existing plugin's supported update controls when replacing its package; the create-plugin form does not update an installed plugin.

Never submit the private reference archive to the public directory. OpenAI currently excludes app references from directory ZIP submissions.

Sources: ChatGPT plugin management and OpenAI submission requirements.

What gets captured

The plugin and CLI capture your Claude Code or Codex session content into thinqOS. That is the product, not a side effect, so here is precisely what happens.

What is sent. Session transcripts: your prompts, the assistant's responses, and tool calls with their results, along with the session id, working directory, and timestamps. Transport is HTTPS to the thinqOS server this machine is connected to (https://app.thinqos.com unless you connected to another deployment), authenticated with your own API key. Data goes to your Mind and is scoped to your identity.

When it is sent. On the Stop hook at the end of a turn, and on PostToolUse for crash-safe mid-session snapshots, debounced to at most one post per 90 seconds (THINQOS_INCREMENTAL_MIN_INTERVAL_S). Both detach first. If the network is unavailable, payloads queue locally under ~/.config/thinqos and are replayed later.

What is filtered before sending. The privacy model is opt-out: the adapter captures everything except

• content matching secret-shaped patterns (.env references, api_key / secret / password / token assignments of 16 or more characters, and sk-… style keys),
• tool results larger than 32 KiB,
• any session whose working directory matches your path denylist (below).

This is a best-effort filter over a broad surface, not a guarantee. Treat it as defense in depth, not as a reason to run the plugin over a directory holding credentials.

Your data is governed by the thinqOS Privacy Policy and Terms of Service.

Controlling and deleting your data

• Exclude directories from capture. Create ~/.config/thinqos/denylist.txt, one substring per line (# starts a comment). Any session whose working directory contains a listed substring is dropped before upload.

  # ~/.config/thinqos/denylist.txt
  /clients/acme
  /secrets
  

• See what was captured: thinqos list

• Delete one session (not reversible): thinqos forget <session_id>

• Stop capturing entirely: disable the plugin in your host and run thinqos uninstall to remove the local hooks.

Notes

• The plugin auto-updates via the marketplace; the CLI self-updates daily (stamp-gated) from the SessionStart hook.
• Codex users: keep using thinqos install --client codex; the marketplace owns MCP, while the CLI resolves the paired connection and owns native hooks.
• To select another deployment, use thinqos install --client codex --base-url <URL> with that deployment's authentication. The plugin follows the paired connection.

Contributing and support

Issues and pull requests are welcome on this repository. For account, billing, or data questions, contact [email protected].

License

MIT. See LICENSE. The MIT license covers the plugin code in this repository; the hosted thinqOS service it connects to is governed separately by the Terms of Service.