Power your agent
คำสั่งของผู้เผยแพร่เอง ไม่ใช่เอนด์พอยต์ของ PlugMCP
Host a copy with our keys and logs.
npx -y [email protected]Claude Code ไม่มีลิงก์ติดตั้งสำหรับคำสั่งแบบโลคัล ให้คัดลอกคำสั่งด้านล่างแล้วรันในเทอร์มินัล
claude mcp add caveat-cli -- npx -y caveat-cli@0.21.19รันในเทอร์มินัล
{ "mcpServers": { "caveat-cli": { "command": "npx", "args": [ "-y", "[email protected]" ] } }}claude_desktop_config.json
URL แบบรีโมตหรือคำสั่งบนเครื่องของคุณ? การติดตั้งสองแบบต่างกันอย่างไร
รันบน PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
เปิดStop rediscovering the same trap. Caveat is a long-term memory layer for Claude Code, Codex, and Cursor: every time you bleed for an external-spec quirk or a repo-specific oddity, write it down once — and the next time anyone (you or your AI) is about to step on the same rake, the relevant note surfaces automatically.
🇯🇵 日本語版: README.ja.md
Built and maintained by Quo at kitepon.dev.
This repository owns Caveat's install, configuration, state, schema, migrations, diagnostics, recovery, updates, and releases. Caveat operates standalone. dotagents owns optional cross-product integration and compatibility contracts; it does not control Caveat's product state. The third-party MarkItDown CLI is managed separately.
npm install -g caveat-cli
caveat init # provisions state and available Claude/Codex/Cursor integrations
On macOS with Homebrew Node, generated hook commands use the stable
/opt/homebrew/bin/node symlink when it resolves to the current Node binary,
instead of a versioned /opt/homebrew/Cellar/node/<version>/... path. That keeps
Claude Code, Codex, and Cursor hooks alive across Homebrew Node upgrades.
With Claude Code, Codex, or Cursor hooks enabled:
UserPromptSubmit hook surfaces matching entries via three structural gates: co-occurrence + symptom-section match + rare topical anchor. No keyword lists. Bare proper-noun mentions (RTX 5090 CUDA で何かやってる) stay silent; specific failure vocabulary plus a curated topic anchor (cudaGetDeviceCount が 0 を返す) fires the right entry. (details)UserPromptSubmit. Claude Code also registers PostToolUseFailure for current failed-tool payloads.Stop queues only new signal kinds and newly matched traps for the next hook tick. With Jev explicitly enabled, the next prompt instead uses three completed Throughline turns to judge repeated struggle and select up to three local knowledge search terms for an AND query.Claude receives Caveat reminders as <system-reminder> blocks and can use the
MCP tools to search, record, and update entries. A primary Codex session uses
Codex's native hook runtime and Codex-formatted hook output. That path calls
Caveat CLI directly. Jev-based struggle detection is opt-in and uses Throughline's
three-turn context projection.
Cursor uses its native beforeSubmitPrompt, postToolUse,
postToolUseFailure, and stop events. Caveat formats the same retrieval and
pending-reminder results for Cursor without replacing unrelated Cursor hooks.
For unmanaged npm installations, the next action in a reminder follows the active host. Claude uses the Caveat
MCP tools. Codex and Cursor inspect an entry with
caveat show <id> --source <source>, update or create Markdown in the own
knowledge repo, and run caveat index. Community entries are subscriptions and
are not edited locally.
The knowledge repo is plain markdown-in-git. Open it as an Obsidian vault. Use
caveat sync for a private team/ownership boundary and caveat publish for a
sealed public mirror. There is no central server — trust is defined socially,
by who you choose to subscribe to via caveat community add <github-url>.
Status: v0.21.9 candidate. Claude Code, Codex, and Cursor have native integration paths. Single-user and small-team workflows are the primary supported path. There is no central DB and install does not auto-subscribe to one.
Managed AI guidance uses the registered caveat_get, caveat_update, caveat_record, and caveat_sync tools instead of a PATH command. caveat_sync pushes private knowledge to its configured remote; the client retains its permission checks. Client timeout does not cancel an active sync. Inspect deployment status → ownSync for its late result; a running receipt is not success. If the MCP tool is unavailable, stop rather than using a global CLI or another context.
With Jev enabled, Caveat stores each completed three-turn judgment, search terms,
candidate scores, and delivery outcome locally under <caveatHome>/jev-observations/.
Run caveat serve and open /jev to inspect cases and reviewed accuracy. Use
caveat jev review <case-id> correct|incorrect|missed|none|unclear --note "reason"
to label a case. Caveat stores references to the source turns rather than copying
their conversation text.
Earlier versions ran a central shared community DB with caveat push (fork + PR) and auto-subscribe on caveat init. That model was retired because trust over arbitrary stranger contributions cannot be reliably automated — sophisticated malicious payloads survive static gates and adversarial-gradient attacks against any LLM-based oracle. xz-utils-style long games are undetectable by static review. Trust is now defined socially (you, your team, your org). See docs/01_plan.md and the abandoned auto-merge design.
Two tiers, distinguished by third-party reproducibility:
Claude's caveat_record tool description and the Codex/Cursor native reminder
use the same binary criterion; explicit user instruction always overrides. The
pre-commit gate in this tool repository protects its public dogfood entries/;
user-owned private repositories may contain both tiers and caveat publish
enforces the public boundary. Retrieval is deliberately flat. See the current
product contract.
flowchart LR
subgraph KB["Knowledge repo (markdown-in-git)"]
MD["entries/*.md<br/>(public + private)"]
end
MD -->|caveat index| FTS[("SQLite + FTS5<br/>trigram")]
subgraph AG["Agent session (Claude Code / Codex / Cursor)"]
P["User prompt"]
T["Tool error<br/>(is_error: true)"]
S["Session end<br/>(transcript signals)"]
end
P -.->|"UserPromptSubmit<br/>事前発火"| H1{"co-occurrence<br/>+ symptom<br/>+ topical anchor"}
T -.->|"PostToolUse<br/>実行中発火 ~20ms"| H2{"async detached<br/>worker"}
S -.->|"Stop<br/>事後発火"| H3{"signal-gated<br/>+ FTS"}
H1 --> FTS
H2 --> FTS
H3 --> FTS
FTS ==>|matched entries| R["Claude: <system-reminder><br/>Codex / Cursor: native hook output"]
R ==> AG
markdown-in-git is the source of truth. SQLite (FTS5 trigram) is a rebuildable derived index, gitignored.~/.caveat/own/ is yours. caveat sync mirrors it (public + private) to a private remote for your machines/org — refusing any anonymously-readable remote. caveat publish mirrors only public entries to a public repo. Subscribers add a repo with caveat community add <github-url-or-username>; updates flow via caveat community pull. No central server; no automatic merge of strangers' entries — trust stays social.visibility: public | private is a distribution ceiling. Private repos may contain both tiers; caveat publish filters and seals the public boundary.caveat_search / caveat_get / caveat_record / caveat_update / caveat_list_recent / caveat_pull / caveat_sync) plus hooks. Codex and Cursor get native hooks through their product-owned installers. All surfaces reuse the same retrieval gates — no hardcoded keyword lists:
## Symptom section (failure-state evidence), (3) ≥ 1 corpus-rarest prompt token in topical_text (title + tags + environment values, topic evidence). Bare proper-noun mentions like RTX 5090 CUDA で何かやってる stay silent; only specific failure-state vocabulary plus a curated topic anchor (cudaGetDeviceCount, SQLITE_READONLY, …) fires the gate. No hardcoded word lists.is_error: true or Claude Code emits a failed-tool error payload, Claude spawns a detached worker so the foreground hook returns in ~20ms. Codex performs a bounded foreground lookup because current Codex payloads and transcript timing make detached workers unreliable there. In both cases, the reminder lands on the next hook tick. The next hook tick emits only knowledge not yet delivered in that session.caveat codex-hook install registers
UserPromptSubmit, PostToolUse, and Stop in ~/.codex/hooks.json and
enables [features].hooks = true. Existing codex_hooks = true installs are
migrated to the canonical key. It reuses Caveat's existing search,
pending-reminder, and stop-signal logic with Codex-specific payload parsing
and stdout formatting. Claude hook stdout is at most one
<system-reminder> block per invocation; Codex hook stdout is a single JSON
object per invocation. Pending reminders are compacted before being joined
into one host-specific context string.caveat cursor-hook install upserts
beforeSubmitPrompt, postToolUse, postToolUseFailure, and stop in
~/.cursor/hooks.json, preserves unrelated hooks, and uses Cursor-native
output shapes for context injection and pending reminders.caveat index.packages/core/ @caveat/core — DB (node:sqlite + FTS5 trigram), indexer, frontmatter,
env fingerprint, repository, record/update, community, paths,
shared hook retrieval logic (claudeHooks.ts; Claude name
retained for the canonical Claude contract)
apps/cli/ caveat-cli (published to npm) — bundled CLI with subcommands:
init / uninstall / index [--full] / search / list / stale / show /
stats / serve / mcp-server / hook <name> / community add|pull|list /
codex-hook install|uninstall|diagnostics|... /
cursor-hook install|uninstall|diagnostics|... /
factory-diagnostics [--require-connector cursor|grok] /
jev enable|disable|status
apps/mcp/ @caveat/mcp — stdio MCP server exposing 7 tools via
@modelcontextprotocol/sdk. Imported by caveat-cli as `mcp-server`
apps/web/ @caveat/web — Hono SSR read-only share portal (/, /g/:id, /community) +
custom markdown-it wikilinks plugin for [[slug]] → /g/slug rendering
hooks/ pre-commit-visibility-gate.mjs (run by .husky/pre-commit) — thin
re-export wrapper around @caveat/core's findBlockedFiles
.husky/ git pre-commit wiring (husky 9)
docs/00_overview.md Documentation map and reading order
docs/01_plan.md Current product, state, sharing, and ownership contract
docs/03_dual_agent_support.md
Claude/Codex/Cursor host contracts, Jev judgment, and smoke notes
docs/04_release_checklist.md
Required publish and post-publish verification checklist
docs/adr/ Architecture decision records
docs/archive/ Completed plans, handoffs, audits, release ledgers, and superseded drafts
rag/ Research asset ledger; currently only INDEX.md
npm install -g caveat-cli and reopen your AI client. Registrations use the node command from the client environment; they do not pin a version directory or require a host shim. Node installation is a product dependency, not a migration proof.runtime.node, runtime.execPath, runtime.sqlite). Verified CI versions from PR59 run 40253098781: Linux 24.20.0; macOS 26.12.1; Windows 24.22.1. Only values from the corresponding PR59 job raw logs are used here.pwsh.exe）を使います。エラー収集用ストレージのACL処理も同じ入口です。package.json's packageManager).simple-git shells out to the system git).npm install -g caveat-cli
caveat init # one-time setup (see below)
caveat search "rtx" # search your local entries
caveat community add https://github.com/acme-corp/caveats # subscribe to a group repo
caveat pull # git-pull subscribed repos and re-index
caveat serve # http://localhost:4242/ read-only portal
What caveat init does:
~/.caveatrc.json (empty {} — defaults come from a constant in the CLI)~/.caveat/own/ (your knowledge repo root) + ~/.caveat/index/caveat.dbUserPromptSubmit / PostToolUse / PostToolUseFailure / Stop hook entries into ~/.claude/settings.json (existing entries preserved; backup written before any change)CodexのCLIまたは設定ディレクトリ、Grok・Cursorの設定ディレクトリが存在する場合は、同じinitがMCPも登録します。
NodeとCaveatの実行パスを登録し、既存の環境変数・timeout・無効化指定・他の登録は保持します。
設定を書き換える前にバックアップし、登録の読戻しが失敗した場合は非0終了します。
独自の設定先はCODEX_HOME / GROK_HOME / CURSOR_HOME / CLAUDE_CONFIG_DIRで指定できます。
--skip-codex-hookと--skip-cursor-hookはhookだけを省略し、MCP登録は行います。
private remoteの初期化・同期も行う場合は、次の入口を使います。--yesは端末でも質問を挟まず、
公開ミラーは明示しなければ変更しません。新規remoteの作成には認証済みのghが必要です。
caveat init --sync --yes
更新時も同じ入口で実行パスと連携設定を更新します。
npm install -g caveat-cli@latest
caveat init --sync --yes
It uses the GitHub account currently authenticated in gh, creates that
account's conventional private repository when absent, checks out or syncs an
existing remote, and configures every available integration above. Re-running
the command is idempotent, and an explicitly requested sync failure exits
non-zero. Callers do not inspect Caveat's state, switch GitHub identities, or
run host-specific Caveat hook installers around this entry.
Use --skip-claude to skip Claude Code wiring, or --dry-run to preview. caveat uninstall reverses Claude Code changes without touching ~/.caveat/. No central DB is auto-subscribed — add knowledge sources explicitly with caveat community add.
For a targeted Codex repair, run caveat codex-hook diagnostics and then
caveat codex-hook install. Diagnostics reports hook availability separately
from whether Caveat-owned hooks are installed.
For a machine-readable product gate, use caveat factory-diagnostics --json.
The versioned caveat.native_factory_diagnostics.v1 output includes
connectors.cursor.compatibility_status, while the base command preserves the
existing Claude/Codex readiness meaning. A host that requires Cursor runs
caveat factory-diagnostics --json --require-connector cursor; a missing,
partial, or non-canonical Cursor connector then makes overall.status
non-ready and the command exit non-zero. Consumers validate schema, then use
only top-level overall.status and the exit status for the gate. Caveat owns
the required Cursor hook set, command shape, and timeout; callers do not
reconstruct those details from ~/.cursor/hooks.json or the per-hook fields.
For a Grok host, use caveat factory-diagnostics --json --require-connector grok.
This checks the enabled MCP registration and its executable paths. Run an MCP
connection smoke and a model session separately to verify live use.
Runtime error collection is local and disabled by default. Enable it in
Caveat's existing user config, ~/.caveatrc.json; no second config file or
host-level controller is required:
{
"runtimeErrors": true
}
Keep any existing keys in that JSON object. A missing key, false, malformed
JSON, or any value other than the boolean true leaves collection disabled.
Inspect and maintain the bounded local store with:
caveat runtime-errors diagnostics --json
caveat runtime-errors snapshot --json
caveat runtime-errors hook-details --json
caveat runtime-errors ack <cursor> --json
caveat runtime-errors resolve <fingerprint> --json
caveat runtime-errors reopen <fingerprint> --json
caveat runtime-errors compact --json
The state file is
$XDG_STATE_HOME/caveat/runtime-errors.json (default
~/.local/state/caveat/runtime-errors.json) on POSIX and
%LOCALAPPDATA%\caveat\runtime-errors.json on Windows. If diagnostics reports
unavailable, repair that file's owner/permissions or move a corrupt file aside
for inspection before recording again. Re-indexing the knowledge database or
reinstalling hooks does not repair this independent runtime error store.
For hook failures, hook-details reads the latest 64 local diagnostics from
hook-diagnostics.json beside that state file. Each diagnostic contains only
the time, version, host error code, failed phase, and a fixed cause category
(for example, sqlite_busy). Exception messages, prompts, paths, and stack
traces are never stored there. Collection uses the same runtimeErrors opt-in;
these details are excluded from snapshots and collector reports. Earlier
versions did not save these details, so old failures cannot be reconstructed.
Concurrent index writes wait up to one second per SQLite operation before
reporting a lock failure; longer contention still produces an error.
Handled sync cancellation, protected refusals, safely aborted conflicts and
surfaced remote failures do not automatically create app repair records. Sync
shows a failure, retains local entries and states that the remote result/cause
may be unknown. Failed rebase recovery is still reported as high impact.
Severity follows observed impact: one failed operation is warn, unavailable
features or failed recovery are high, and confirmed data loss is fatal.
Counts never raise severity. Serious unresolved impact and legacy history are
preserved; cause and recovery still require investigation. See the
product reporting contract.
Caveat sends runtime errors nowhere by default, and the package contains no destination. If you run a collector that issues signed-report credentials, name the credential file in the same user config:
{
"runtimeErrors": true,
"runtimeErrorReportCredentialFile": "/absolute/path/to/caveat.json"
}
Both keys are required: without runtimeErrors: true nothing is recorded, and
without an absolute credential path nothing is sent. The credential file is
issued by the collector and holds url, key_id, and secret. Caveat
refuses it, and sends nothing, unless it is a regular file (not a symlink) that
only you can read: on POSIX, owned by you with no group or other permission
bits; on Windows, owned by you or Administrators with no access for anyone
other than you, SYSTEM, and Administrators.
A report is one POST to url carrying schema_version, report_id,
product_id, installed_version, observed_at, the unacknowledged
runtime_errors (fingerprint, error code, component, fixed message template,
severity, status, occurrence count, first/last seen, the version it occurred
on) and resolutions. It never contains prompts, entry or file contents,
paths, host names, stack traces, or stderr. The secret is not transmitted: the
request is signed with
Authorization: BugHub-HMAC-SHA256 key_id=<key_id>, ts=<unix seconds>, sig=<hex>,
where sig is HMAC-SHA256(secret, ts + "\n" + hex(SHA-256(body))).
Records stay pending until the collector answers 200 with accepted: true,
the same report_id, and a receipt sig equal to
HMAC-SHA256(secret, report_id + "\n" + received_at). Any other answer,
including an unsigned 200 and a redirect, leaves them pending for a later
attempt, and a failed send is never itself recorded as a runtime error.
A detached worker sends after a hook failure and at session stop, only when something is pending, so hooks never wait on the network. After an accepted report the worker waits one hour; after a network or server failure, ten minutes; after a clock mismatch, one hour; after a credential or report rejection, six hours. To send immediately or inspect the last outcome:
caveat runtime-errors report --json # exit 1 when the send failed
caveat runtime-errors report-status --json
Remove runtimeErrorReportCredentialFile to stop sending; local collection is
unaffected.
visibility is a distribution ceiling. Two commands enforce it:
caveat sync — sync your whole ~/.caveat/own/ (public and private entries) to a private git remote. This is how you keep your knowledge in step across your own machines, or share it inside an org — anyone with push/pull access to that private repo is inside your boundary. Before pushing, Caveat probes the remote and refuses to push if it is anonymously readable (a public repo), so private entries never leak by misconfiguration.
caveat sync --init # gh-creates <you>/Caveat-Private (private), first push
caveat sync # thereafter: commit → pull --rebase → reindex → push
caveat sync --init --repo https://github.com/acme-corp/Caveat-Private.git # org / self-hosted
Once a private remote is configured, Caveat also syncs on its own — a gotcha you hit on one
machine is worth little if it reaches the others two days later. A background worker runs the same
cycle within a minute of recording an entry, and otherwise at most every 15 minutes when a session
ends. It never blocks you, it obeys the same refuse-if-anonymously-readable rule, and repeated
failures back off rather than stopping silently. Set CAVEAT_AUTO_SYNC=off to sync only by hand.
For an OS scheduler, caveat autosync run --json waits for one cycle and emits its result.
It uses the existing 15-minute interval and failure backoff, skips uncommitted work, and shares
repository/index locks with manual and hook sync. Exit status is 0 for completed sync and indexing,
2 for an intentional skip, and 1 for failure. caveat autosync status --json retains the last actual
attempt, last failure, and last successful completion even after a skipped invocation. These commands
do not install an OS schedule; a sleeping or stopped terminal cannot receive updates.
To explicitly opt in, preview caveat autosync schedule install --json --dry-run, then omit
--dry-run to register a current-user systemd timer, launchd agent, or Windows task.
autosync schedule status --json reads registration and autosync schedule uninstall --json
removes only the owned definition. Edited definitions and foreign jobs are refused.
Registration fixes the current Node/CLI paths, Caveat home and configuration home; rerun install
after moving them. Jobs wake once a minute and use the existing interval/backoff. User sessions
and native schedulers must be available; registration does not prove successful reception.
caveat publish — scan only visibility: public entries, then generate a
deterministic AES-256-GCM sealed bundle plus a generated README. The public
mirror contains only README.md and bundle/entries.caveat; non-showcase
entry text is not materialized as a plaintext tree. Invalid entries or a
failed outbound scan abort the whole publish. Configure publishTarget,
sealedKeyserverUrl, and sealedKeyId first; see
keyserver/README.md.
caveat publish --init # gh-creates <you>/Caveat-Public (public)
caveat publish # seal public entries, show the logical diff, confirm, push
Others read your public repo with caveat community add <you> (a bare GitHub
username expands to <you>/Caveat-Public) then caveat pull. Caveat obtains the
declared content key and decrypts the bundle in process memory for indexing; the
sealed tier deters casual browsing and crawlers, but it is not authentication
against a motivated human. There is still no central server and no automatic
merge of strangers' contributions.
The entries/ directory in this tool repository is intentionally retained as
dogfood and format examples. It is not the canonical published knowledge set;
that boundary is the generated Caveat-Public repository produced by
caveat publish.
~/.caveat/own/Write ~/.caveatrc.json:
{
"knowledgeRepo": "/absolute/path/to/your/caveats-repo"
}
(v0.2+) source_project is always written as null by caveat_record. It used to be auto-inferred from cwd via a projectRoots config field, but that leaked per-user project names into publicly-shared knowledge repos and has been removed. Set it manually in the md file if you want personal traceability on private entries.
corepack pnpm install
corepack pnpm -r build
cd apps/cli && corepack pnpm pack # caveat-cli-<ver>.tgz
npm install -g ./caveat-cli-<ver>.tgz # now `caveat` is on PATH
For npm releases, push an annotated version tag after CI passes. The
publish-npm.yml workflow packs apps/cli with pnpm and publishes that tarball
through npm Trusted Publishing. Do not run npm publish on the workspace
source; pnpm normalizes workspace dev dependencies in the packed manifest,
while npm leaves workspace:* strings intact.
Release work is not done at publish time: follow
docs/04_release_checklist.md through fresh npm
install, Claude/Codex new-session smoke, Cursor install/diagnostics smoke, CI,
and npm registry verification.
For iterative dev, npm link inside apps/cli/ keeps the global shim tracking your local build.
The tool repo has .husky/pre-commit wired to protect its public dogfood
entries/. Use the same gate only in a repository that is intentionally
public-only. Do not add it to the private repository managed by caveat sync;
that repository is allowed to contain both tiers, and caveat publish enforces
the public boundary.
cd /path/to/your/caveats-repo
npm init -y # or pnpm init
npm install --save-dev husky
npx husky init
# Copy the gate script:
cp /path/to/Caveat/hooks/pre-commit-visibility-gate.mjs hooks/
# Edit .husky/pre-commit to exec that script (one line: `exec node "$(dirname "$0")/../hooks/pre-commit-visibility-gate.mjs"`)
The gate rejects any commit that stages an entries/**/*.md with
visibility: private. It is a dogfood/public-only repository guard, not the
normal private-sharing mechanism.
Your knowledge repo (default ~/.caveat/own/) is a valid Obsidian vault. File → Open folder as vault. Recommended plugins:
Caveats authored in Obsidian are picked up by caveat index on next run (FTS is eventually consistent; MCP caveat_record syncs immediately).
caveat community add https://github.com/alice/caveats-alice
caveat community pull # refresh all subscribed repos
caveat community list
caveat community remove <handle> # unsubscribe + purge db rows
caveat index # re-index to pick up new entries (or use `caveat pull` for the combined flow)
# Then search only their contributions:
caveat search "foo" --source community
URL validation is strict — only ^https://github.com/<org>/<repo>(\.git)?/?$ is accepted. GitLab / SSH / HTTP are rejected in v1.
Each caveat is a markdown file with YAML frontmatter. Example:
---
id: rtx-5090-cuda-12-compat
title: RTX 5090 で CUDA 12.4 以前が初期化失敗する
visibility: public
confidence: reproduced # confirmed | reproduced | tentative
outcome: resolved # resolved | impossible
tags: [gpu, nvidia, cuda]
environment:
gpu: RTX 5090
cuda: ">=12.5"
source_project: llm-infer-bench
source_session: "2026-04-18T12:34:56Z/abcdef012345"
created_at: 2026-04-18
updated_at: 2026-04-18
last_verified: 2026-04-18
---
## Symptom
## Cause
## Resolution
## Evidence
The canonical entry shape is Frontmatter in
packages/core/src/types.ts, the derived index is
packages/core/src/schema.sql, and MCP input
schemas live beside the handlers in apps/mcp/src/tools/.
corepack pnpm -r test
corepack pnpm -r typecheck
corepack pnpm -r build
Per-package:
corepack pnpm --filter @caveat/core test
corepack pnpm --filter caveat-cli test
corepack pnpm --filter @caveat/mcp test
corepack pnpm --filter @caveat/web test
corepack pnpm --filter @caveat/hooks test
Contributing: see CONTRIBUTING.md.
Record/update arguments and final Markdown are limited to 1MiB of UTF-8; frontmatter to 64KiB, an expanded 10,000-node/edge graph and depth128. Oversized writes fail before file/index mutation with a typed error. Existing oversized entries remain on disk and readable; searches continue and stale index rows are retained. Run caveat index, then caveat entry-diagnostics --json to see skipped/stale source paths and limits. Use caveat show --path misc/example.md --limit-bytes 65536 or caveat_get with that relative path to read explicit raw windows and follow their next byte offset. Ambiguous YAML numeric/date-shaped strings are selectively quoted, while legacy numeric meanings are preserved.
MIT
Factory private evidence v1 is an isolated, default-OFF contract candidate. This build declares no supported transports; it sends and stores no private evidence. The product owns the protocol and missing-evidence rules.
For side-by-side releases with a stable MCP/hook entry, use caveat deployment stage --json, then caveat deployment activate <release-id> --json. Run the returned fixed launcher with the existing Node for init. Later updates and rollbacks select an already verified release through the same command; registration strings stay unchanged. caveat deployment status --json verifies the selected payload. The initial migration needs one normal Codex hook review. Deployment does not grant trust or change Node/PATH; see the managed deployment contract.
For private GitHub sync, set the optional non-secret "githubUser": "your-account" in ~/.caveatrc.json to select an already authenticated account. Caveat passes an account-specific helper only to its Git/diagnostic children and calls gh auth token --user ... --no-refresh. It does not switch shared accounts or refresh credentials. Missing accounts, incompatible gh and expired credentials fail explicitly; re-authentication belongs to the owner. Without this field the previous behavior is retained. A configured account requires an explicit private HTTPS GitHub URL when initializing a new sync repository. The selected instance discards inherited Git config/protocol overrides and trace output, neutralizes configured helpers and authentication headers, and never persists its policy. The gh entry is fixed to /usr/bin/gh on Linux, /opt/homebrew/bin/gh on macOS, and C:\Program Files\GitHub CLI\gh.exe on Windows; no PATH fallback is used.
The unreleased deployment registration-plan / registration-migrate commands
replace only the fifteen reviewed Node tokens in a saved seven-file projection.
Native originals are preserved and known-only recovery uses a new journal.
Planning and journal inspection do not grant execution permission. See the
saved registration contract.
caveat deployment status --json reports old running MCP server PIDs and their parent applications, with an instruction to reopen that client. New servers record their loaded version in a local lifetime receipt, so an installation update does not rewrite that version. Older installations without receipts can be identified from readable script paths. This diagnostic does not terminate or restart clients. A cached script from a pre-receipt in-place update may be unobservable.
Long-term memory CLI for Claude Code, Codex, and Cursor (markdown + SQLite FTS5 + MCP + hooks)
{ "mcpServers": { "caveat-cli": { "command": "npx", "args": [ "-y", "[email protected]" ] } }}เครื่องมือ
ยังไม่มีรายการเครื่องมือ เซิร์ฟเวอร์แบบรีโมตจะได้รายการหลังการตรวจสอบสถานะครั้งแรก
FAQ
คัดลอกคอนฟิก stdio สำหรับ Cursor, Claude Desktop, Claude Code หรือ VS Code ได้ในหน้านี้ คอนฟิกนี้ใช้การติดตั้งของผู้เผยแพร่ ไม่ใช่พร็อกซีของ PlugMCP
ระเบียนนี้ไม่ได้ระบุตัวแปรสภาพแวดล้อมที่จำเป็น
Caveat Cli ทำงานแบบโลคัลผ่าน stdio
ตรวจสอบล่าสุดเมื่อ 2026-11-14 Long-term memory CLI for Claude Code, Codex, and Cursor (markdown + SQLite FTS5 + MCP + hooks)