vectorize-io/hindsight#coding-agents

Long-term project memory for coding agents, backed by Hindsight. One package, several agents: a shared reflect-and-inject core with a thin entry point per agent (Claude Code, Codex CLI, DeepAgents Dcode, opencode, opencode 2, Kilo CLI, Cursor CLI, GitHub Copilot CLI, Grok Build, Qwen Code, Factory Droid, ZCode, Antigravity CLI, Devin CLI, Cline CLI, pi, Prime Agent, DeepSeek Harness). Ingestion is fully automatic — there is no setup command: a repo's git history and conversations flow into its memory bank in the background as you work.

The premise: most of a real fix is derivable from the code, but the last mile often hinges on a project-specific decision that isn't in the code at all — a rounding rule, a retry allowlist, a tie-break policy. Those decisions live in git history and past conversations. This package puts them in front of the agent at the moment it starts working, and keeps a curated set of knowledge pages (architecture, conventions, in-flight initiatives) that future sessions start from.

View Changelog →

Install

npx @vectorize-io/hindsight-coding-agents install all          # every detected agent, wired natively
npx @vectorize-io/hindsight-coding-agents install claude-code  # or just one
npx @vectorize-io/hindsight-coding-agents uninstall all        # removes exactly what install added
npx @vectorize-io/hindsight-coding-agents update               # refresh the runtime only, no rewiring
npx @vectorize-io/hindsight-coding-agents stats                # how often each agent uses Hindsight

install takes an explicit target — all, or one or more harness names. A bare npx @vectorize-io/hindsight-coding-agents install changes nothing and prints the choice, so wiring every agent on the machine is never something that happens by accident. Updating is the same install command again — it re-copies the runtime in place.

Day to day you should not have to: once a day, a session start checks npm and re-stages a newer runtime in the background (autoUpdate, on by default — set it to false to pin the version you have). That is the update command above, which refreshes the copy every wired agent already points at and deliberately touches no host config; re-run install yourself after a release that adds a new hook, or to wire another agent.

On a terminal it also asks where memory should live — Hindsight Cloud, a server you run, or a local daemon on this machine (see Where memory lives). Scripted installs pass --server cloud|self-hosted|daemon instead; it is asked only once, and never again on re-install.

Per agent

Same command, only the harness name changes. Run after installing the package globally.

Claude Code

npx @vectorize-io/hindsight-coding-agents install claude-code

3 hooks in ~/.claude/settings.json, MCP via claude mcp add (user scope), and the companion skill.

Codex CLI

npx @vectorize-io/hindsight-coding-agents install codex

3 hooks in ~/.codex/hooks.json plus [mcp_servers] in config.toml (needs codex_hooks = true).

DeepAgents Dcode

npx @vectorize-io/hindsight-coding-agents install dcode

The installer registers this package as a local marketplace with Dcode, then invokes Dcode's own plugin install command. The package is a native Agent Plugin: its root plugin.json contributes the shared skill, the Hooks V2 SessionStart, UserPromptSubmit, and Stop lifecycle, and the namespaced hindsight_* MCP server. Enable the plugin through Dcode's normal plugin manager; no Dcode config patcher or compatibility bridge is required.

Dcode namespaces a plugin's MCP tools, so they appear as plugin__hindsight-coding-…__hindsight_… rather than under their bare names — the agent resolves them from the tool guide either way. In headless runs (dcode -n) Dcode allows the read-only Hindsight tools and gates the two that write (hindsight_ingest_document, hindsight_capture_initiative) behind an approval it has no UI for; use the interactive TUI to capture an initiative or ingest a document. For the same reason the one-time codebase survey runs under another installed agent's CLI when there is one, exactly as it does for Cursor, Copilot, Devin, Grok Build, Cline, Kilo and Prime Agent.

opencode

npx @vectorize-io/hindsight-coding-agents install opencode

A plugin entry in ~/.config/opencode/opencode.json — native tools, no MCP needed.

opencode 2

npx @vectorize-io/hindsight-coding-agents install opencode2

opencode v2 (npm @opencode/cli) exposes an opencode2 binary alias alongside opencode and rewrote the plugin API, so it is a harness of its own. It writes the same plugin entry to the same ~/.config/opencode/opencode.json — the two CLIs share that file, and v1 rejects the whole config if it sees v2's plugins key — and each CLI then loads its own entry point from the one registered path. So installing either harness wires both, and uninstalling either removes the shared entry.

Two differences from v1, both because of the host: the one-time codebase survey runs under another installed agent's CLI (v2 plugins cannot define the read-only agent the survey needs), and the seed banner is written to the plugin log instead of a TUI toast (v2 plugins cannot raise one). Recall, injection, the native hindsight_* tools and session write-back are identical. The companion skill is identical too, but it is registered in memory through v2's skill API rather than copied into a skills directory — opencode2 has none of its own, and the two it reads belong to other agents.

Kilo CLI

npx @vectorize-io/hindsight-coding-agents install kilo

A plugin entry in ~/.config/kilo/kilo.json[c].

Cursor CLI

npx @vectorize-io/hindsight-coding-agents install cursor-cli

Hooks in ~/.cursor/hooks.json, ~/.cursor/mcp.json, and the companion skill.

GitHub Copilot CLI

npx @vectorize-io/hindsight-coding-agents install copilot-cli

~/.copilot/hooks/, mcp-config.json, and the companion skill.

Grok Build

npx @vectorize-io/hindsight-coding-agents install grok-build

Native hooks and MCP in ~/.grok/config.toml, plus the companion skill.

Qwen Code

npx @vectorize-io/hindsight-coding-agents install qwen-code

Native hooks in ~/.qwen/settings.json, plus MCP and the companion skill.

Qwen's hook timeout is in milliseconds (its own docs: "Timeout in milliseconds, default 60000"), unlike every other supported agent, so the installed values are 30000/30000/60000. Recall fires on genuine submissions only — UserPromptSubmit also fires on tool-result continuations, so interactive sessions recall once per prompt while headless (qwen -p), serve, SDK and ACP sessions seed and retain but do not recall.

Factory Droid

npx @vectorize-io/hindsight-coding-agents install factory-droid

4 hook registrations in ~/.factory/hooks.json (user scope), including a cancellation-safe Notification write-back, plus a stdio MCP registration under mcpServers.hindsight in ~/.factory/mcp.json, and the companion skill in ~/.factory/skills. The installer touches only JSON files - no Droid CLI round-trip - and refuses to overwrite a user-managed MCP server already named hindsight. Droid's hook protocol matches Claude Code's (session_id/transcript_path/cwd in, hookSpecificOutput.additionalContext out). Recall and injection use the same protocol; write-back also handles Droid's cancellation notification because Droid does not emit Stop after a cancelled turn.

ZCode

npx @vectorize-io/hindsight-coding-agents install zcode

Three hook registrations plus a stdio MCP server under mcp.servers.hindsight, both in ZCode's own CLI config ~/.zcode/cli/config.json - never your real Claude Code settings, even though ZCode embeds the Claude Code agent runtime and speaks its hook protocol. The companion skill goes to ~/.zcode/skills. Config hooks ship disabled, so the installer also sets hooks.enabled to true; uninstall removes the whole block again when nothing else is registered there, and refuses to touch an MCP server named hindsight that it did not write.

ZCode's hook timeoutMs is in milliseconds (installed values 30000/30000/60000), and hooks.maxOutputBytes caps what a hook may print - anything larger is dropped, injection and all. The installer seeds it at 32768 only when your config does not already set one.

ZCode keeps no durable session transcript: Stop carries the reply plus a temp, assistant-only file it deletes as soon as the hook returns, and no user prompt at all. So this is the one agent whose conversation the plugin journals itself - the prompt hook records what you asked, the Stop hook records the reply - and the write-back then behaves like every other agent's, appending each new turn to the same session document. --import-conversations is therefore not available for ZCode: there is no past history on disk to backfill from.

Antigravity CLI

npx @vectorize-io/hindsight-coding-agents install agy

Lifecycle hooks, MCP, and the Hindsight · <bank> status line.

Devin CLI

npx @vectorize-io/hindsight-coding-agents install devin-cli

Hooks in ~/.config/devin/config.json plus MCP. Needs Node 22.5+ — see below.

Cline CLI

npx @vectorize-io/hindsight-coding-agents install cline-cli

A native plugin via cline plugin install, plus MCP and the companion skill.

pi

npx @vectorize-io/hindsight-coding-agents install pi

An extension entry in ~/.pi/agent/settings.json, plus the companion skill in ~/.pi/agent/skills — native tools, no MCP needed.

This command is the only supported route, for pi and for Prime Agent below. Installing us as a pi package (pi install npm:@vectorize-io/hindsight-coding-agents) is deliberately not wired: both hosts read the same pi key of a package's package.json, and that key can only name one entry — whichever host it did not name would load the other's bundle and report itself as the wrong agent, taking that harness's config section and stamping every document it retains with it. So the package carries no pi key at all, and each host is pointed at its own bundle by the install command above.

Prime Agent

npx @vectorize-io/hindsight-coding-agents install prime-agent

Prime Agent is a fork of pi, so it is wired the same way: an extension entry, here in ~/.prime/agent/settings.json, plus the companion skill in ~/.prime/agent/skills — native tools, no MCP needed. Installing both is fine and expected: each host loads its own entry from its own settings file, and like every other pair of agents they share one bank per repo (the default coding-agent::{gitProject}), so what you tell pi is there when you open Prime Agent. Separate entries are what keeps each side attributable — its own harnesses.<name> config section, and its own agent stamped on every document it retains.

DeepSeek Harness

npx @vectorize-io/hindsight-coding-agents install dsh

A Cordis plugin row in $DSH_HOME/cordis.patch.yml (~/.dsh by default), which every dsh profile composes — native tools, no MCP needed. Two dsh-specific notes: one dsh process serves several repositories (its Web UI opens each session in whatever directory you pick), so the bank is resolved per session workspace rather than once per process; and dsh has no plugin-facing notice channel, so the seed line goes to the plugin log rather than the UI. Everything model-facing — recalled memory, the knowledge preamble, the hindsight_* tools — is unaffected. If you prefer the published-package route, dsh plugin --profile web add @vectorize-io/hindsight-coding-agents works too: the package ships the profile patch layer, so nothing else needs editing. Either route gets the companion skill — a plugin wired by the host's own plugin manager installs it itself on the first session, since that route never runs our installer.

Uninstall the same way: npx @vectorize-io/hindsight-coding-agents uninstall claude-code (or uninstall all).

Devin CLI needs Node 22.5 or newer. Its hooks pass only a session id — the conversation itself lives in ~/.local/share/devin/cli/sessions.db — so reading it depends on Node's built-in node:sqlite. Installing devin-cli checks for this first and refuses (with the reason) rather than wiring hooks that could never retain anything. Every other agent works on any supported Node.

install copies what it needs into ~/.hindsight/coding-agents and points each agent's wiring there, so nothing depends on where you ran it from. Updating is the same command again — it re-copies the runtime in place, leaving the wiring valid and every new session on the new version.

install merges the native wiring (hooks + MCP registration where the host wants them) into each agent's own config, preserving everything already there; it is idempotent (re-run after moving the package) and backs up any pre-existing file it touches as <file>.hindsight-backup. uninstall removes only our entries. On Claude Code the install also ships a companion skill (~/.claude/skills/hindsight-coding-agent) that teaches the agent how this memory works — what "store this in hindsight" should do, the tool surface, per-repo configuration, debugging — so users can ask the agent itself. Manual wiring per harness, if you prefer:

opencode and opencode 2 install directly — point opencode.json at the package dir:

{ "plugin": ["/path/to/hindsight-coding-agents"] }

One entry, both CLIs: v1 resolves that directory through package.json main, v2 through its index.js, so each loads its own plugin.

Claude Code and Codex get their full three-hook + MCP wiring from this package's own installer — npx @vectorize-io/hindsight-coding-agents install claude-code / install codex. This package's bin entries (hindsight-claude-hook, hindsight-codex-hook, hindsight-cursor-hook) are the individual injection-only UserPromptSubmit entrypoints for a minimal, hand-wired setup.

Adding an agent: hook-based → write a HookSpec entry point (see src/cursor-hook.ts) and register a hookAdapter in src/harness/registry.ts; persistent-plugin → implement HarnessAdapter (src/core/types.ts) fully (see src/harness/opencode.ts), or bind the host's own plugin API to RuntimeCore directly when it is not an opencode fork (see src/cline.ts, src/dsh.ts).

Migrating from the per-agent plugins

The older per-agent integrations (hindsight-claude-code, hindsight-cursor-cli, hindsight-codex, …) are superseded by this package. Two things move; nothing else does.

Your server moves automatically. If ~/.hindsight/claude-code.json or ~/.hindsight/codex.json exists, install adopts its endpoint — hindsightApiUrl → apiUrl, hindsightApiToken → apiToken, and an empty URL means the local daemon, as it did there. The agent you are installing is checked first, so wiring Codex takes Codex's server even if an old claude-code.json is still lying around. You already chose where your memory lives; defaulting to Cloud instead would quietly send your prompts somewhere else. Pass --server to override. (Those two are the only old plugins that shipped a user config — Cursor CLI, Copilot CLI, opencode and Cline have no endpoint to carry.)

Your conversations are re-imported from local disk, as new documents:

cd /path/to/your/repo
npx @vectorize-io/hindsight-coding-agents install claude-code --import-conversations   # or: install codex --import-conversations

This re-extracts the transcripts the agent already wrote, so it costs tokens roughly in proportion to the history imported, and it is safe to re-run (ingestion dedups by document id).

Local transcripts are the source rather than the old bank, because the old bank cannot be split by repo. Its default was a single static bank — dynamicBankId defaults to false, so everything landed in one bank named claude_code — and its documents record only retained_at, message_count and session_id, nothing identifying the project. Working out which documents belong to which repo means joining session_id back to the cwd in the local transcript, so the transcripts are needed either way; going through them directly is simply the shorter path.

How sessions are matched. A conversation is imported only when the session itself records the directory it ran in — never inferred from a file or folder name. Claude Code writes that directory on its entries, Codex in its session_meta header and DeepSeek Harness in its session-log header, and pi and Prime Agent in their session header, so all five can be attributed exactly, including sessions started in a subdirectory of the repo. Guessing was tempting (Claude names its history folders after the project path) but unsafe: / and . both encode to -, so repo-sub is either the subdirectory repo/sub or an unrelated sibling repo — and a wrong guess files someone else's conversation into your bank. Sessions that record nothing are skipped and the count is reported. DeepSeek Harness logs are Zstandard-framed JSONL under $DSH_HOME/sessions, which needs Node 22.15+ to read; an older Node skips the import with that reason rather than silently importing nothing. Dcode's transcripts record no directory at all — the working directory lives only in its LangGraph checkpoint database — so the repo comes from dcode threads list --json, a declared, versioned command contract rather than that internal schema; with the dcode CLI unavailable the import is skipped with that reason. The other harnesses (opencode, opencode 2, Kilo, Cursor, Cline, Copilot, Devin) keep history in internal SQLite databases with unversioned schemas and are skipped with a reason.

Nothing else is translated. The old plugin's behavioural settings — 12 recall*, 7 retain*, bankMission/retainMission, dynamicBankGranularity — describe a pipeline this package replaced, and reinterpreting them would be guesswork. Bank naming changes too: this package uses one bank per repo (coding-agent::{gitProject}) shared by every agent. To keep the old naming instead:

{ "bankIdTemplate": "{harness}::{gitProject}" } // reproduces the old per-agent naming

Where memory lives

Three modes, chosen once when you install (install asks on a terminal; pass --server to script it):

mode	what runs	needs
cloud	Hindsight Cloud (default)	an API token
self-hosted	a Hindsight server you already run	its URL
daemon	a local hindsight-embed on this machine	uv on PATH + an LLM key for extraction

npx @vectorize-io/hindsight-coding-agents install claude-code --server daemon
npx @vectorize-io/hindsight-coding-agents install claude-code --server self-hosted --api-url http://localhost:8888
npx @vectorize-io/hindsight-coding-agents install claude-code --server cloud --api-token <token>

Re-running install never re-asks: a config that already names a server is left alone.

Local daemon mode

Nothing to sign up for and nothing to host — memory runs on your machine. The plugin starts hindsight-embed on demand at 127.0.0.1:9077 and points every agent at it.

• A server already on the port is adopted, never restarted — so one daemon serves every agent and every repo, and your own hindsight-embed is reused if you already run one.
• Cold starts happen in the background. The first start downloads the daemon and loads models, which takes longer than any hook is allowed to run, so it is launched detached at session start. A session that begins before it is ready simply has no memory for a turn or two — a daemon that isn't up is treated as an unreachable server, exactly like a Cloud or self-hosted outage, with the same error handling and the same diagnostics. Nothing downstream of the URL knows which mode it is.
• It keeps running until you stop it. There is deliberately no stop-on-exit: one daemon is shared, so ending one session must not cut memory out from under another agent still working.
• macOS additionally needs a current Rust toolchain. litellm (a transitive dependency of the API) publishes wheels only for Linux and Windows, so a Mac compiles it from source through maturin and its crates pin a recent rustc. Install from rustup.rs and keep it updated — an out-of-date toolchain fails as surely as a missing one. Linux and Windows install from wheels and need none of this.
• Fact extraction runs locally, so it needs an LLM. HINDSIGHT_API_LLM_PROVIDER wins if set; otherwise the first of OPENAI_API_KEY, ANTHROPIC_API_KEY, GEMINI_API_KEY, GROQ_API_KEY; otherwise the Claude Code CLI, which needs no key. install tells you which it found.

Daemon settings keep the names the old per-agent Claude Code plugin used, so an existing environment carries over unchanged:

field	env	default	meaning
serverMode	HINDSIGHT_SERVER_MODE	cloud	cloud | self-hosted | daemon
apiPort	HINDSIGHT_API_PORT	9077	port the local daemon listens on
daemonIdleTimeout	HINDSIGHT_DAEMON_IDLE_TIMEOUT	—	deprecated, ignored: the daemon no longer exits on its own
daemonProfile	HINDSIGHT_DAEMON_PROFILE	coding-agent	which local database it uses
embedVersion	HINDSIGHT_EMBED_VERSION	latest	which hindsight-embed release to run
embedPackagePath	HINDSIGHT_EMBED_PACKAGE_PATH	—	run a local checkout instead (development)

Any HINDSIGHT_API_* variable you export is forwarded to the daemon, so server-side settings need no equivalent here.

Configuration

Configuration is one JSON file: ~/.hindsight/coding-agent.json. Layering, later wins per field:

1. built-in defaults
2. environment variables — HINDSIGHT_API_URL, HINDSIGHT_API_TOKEN, and one per scalar setting (HINDSIGHT_<FIELD_IN_CAPS>), for containers and CI that inject config rather than write a file
3. the file's top level
4. its harnesses.<name> section — per-agent override
5. its banks.<resolvedBankId> section — per-repo override, applied after the bank is resolved (see Per-repo opt-in/out)

Environment variables are a fallback: the file wins wherever it sets a value, so adding env to an existing setup changes nothing. The two list-valued settings, retainTags and optInPaths, take a comma-separated value (HINDSIGHT_RETAIN_TAGS="project:{gitProject},env:work"); entries are trimmed and blanks dropped. The map-valued settings (mapPathToBank, harnesses, banks, retainMetadata) are file-only — per-key branching doesn't survive flattening into one variable. maxParallelRetains is available as HINDSIGHT_MAX_PARALLEL_RETAINS for containers and CI.

HINDSIGHT_CONFIG moves the file itself — point it at another path for a container or a test harness where $HOME is not the right anchor. It is still exactly one file; only its location changes. (The other variables that are not settings are HINDSIGHT_LOG_FILE, HINDSIGHT_DIAG_FILE, HINDSIGHT_USAGE_FILE and HINDSIGHT_LOG_LEVEL — see Diagnostics & logging.)

When a change takes effect

Config is read when a process starts — the file is not watched — so when an edit applies depends on what reads it:

host	reads the file	an edit applies
hook harnesses (Claude Code, Codex CLI, Cursor CLI, GitHub Copilot CLI, Grok Build, Antigravity CLI, Devin)	once per hook invocation — each hook is its own short-lived process	on your next prompt
persistent plugins (opencode, opencode 2, Kilo CLI, Cline CLI, pi, Prime Agent, DeepSeek Harness)	once per workspace, when the host loads the plugin	after restarting the agent
the MCP server behind the hindsight_* tools	once at startup	in your next session

apiToken is the exception. Every host re-reads it when the server rejects a request, so enabling authentication or rotating the key is picked up on the next call with nothing to restart — otherwise a rotation would leave a long-running agent failing every memory call until it was restarted. Everything else follows the table: apiUrl, disabled, bank routing, gitIngest, and the survey and knowledge-page settings.

hindsight_diagnose reports both sides of that gap — what the file says now, and what the running client is actually using.

Opt-in only

By default every project gets memory — that is what makes the plugin zero-setup. If you would rather nothing be remembered until you say so, turn memory off everywhere and name the projects that may use it:

{
  "optInOnly": true,
  "optInPaths": ["~/work/client-x", "~/oss"],
}

Anything outside those paths is inert: no bank is created, nothing is retained, no seed runs, and the agent behaves exactly as it would without the plugin. Approving costs nothing else — optInPaths says which projects, not which bank, so an approved repo keeps its usual coding-agent::{gitProject} name. Paths are prefixes, so approving ~/work approves every repo under it while each still gets its own bank.

A mapPathToBank entry counts as opted in too, since routing a path to a named bank already declares that project. A bare bankId does not: it names a bank rather than a project, so it cannot say which work may be remembered, and a privacy switch has to fail closed.

There is no per-repo opt-in file, for the same reason there is no repo-carried config at all: a cloned repository must not be able to turn memory on.

There is deliberately no repo-carried config file — per-repo bank routing is mapPathToBank, per-agent differences are harnesses.<name>.

Each entry point knows which harness it is (the opencode plugin is loaded by opencode, the codex hook by Codex...), so one shared config serves several agents side by side:

{
  "apiUrl": "https://api.hindsight.vectorize.io",
  "harnesses": {
    "opencode": { "reflectTimeoutMs": 60000 },
    "claude-code": { "disabled": true }, // e.g. memory off for Claude only
  },
}

Reference

field	default	meaning
apiUrl	https://api.hindsight.vectorize.io	Hindsight API base URL (set to http://localhost:8888 for a local server)
apiToken	—	bearer token (Hindsight Cloud). Picked up without restarting the agent: a long-lived host re-reads it after a rejected request, so enabling auth or rotating the key mid-session recovers on the next call
bankId	—	explicit static bank; unset ⇒ per-repo dynamic resolution (below)
dynamicBankId	dynamic iff no bankId	force dynamic (true) or static (false) resolution
bankIdTemplate	"coding-agent::{gitProject}"	dynamic bank id format; the default makes every agent share one bank per repo
mapPathToBank	—	absolute path → bank; longest prefix wins; linked worktrees inherit their main checkout's mapping; overrides everything
optInOnly	false	run memory ONLY in opted-in projects — everything else is inert, with no bank created; see Opt-in only
optInPaths	—	directories opted in, matched as prefixes with ~ expanded; each repo beneath and its linked worktrees are approved while keeping their own dynamic bank
resolveWorktrees	true	linked worktrees inherit the main checkout's bank identity, path approval, and mapping
retainTags	—	extra tags on every document written by the integration, e.g. ["project:{gitProject}"] — see Recording where a memory came from below
retainMetadata	—	extra metadata on every document written by the integration, e.g. {"repo": "{gitProject}"}
retainContext	conversation between the user and you (the coding agent): user turns are the user's words and decisions, assistant turns are yours	the context sent with every session write-back. Extraction reads it to decide whose claim a sentence is, so the default names both speakers. Accepts the same {placeholder} templates as retainTags
manageBankConfig	true	let the plugin shape the bank's own configuration — the retain strategies it writes under, the knowledge entity-label group, and, on a bank that has none, the missions. Writing is additive: it adds what the bank does not define and never overwrites what is there, so your control-plane edits survive — the one exception is the extraction mode of its own strategies, which follows retainExtractionMode. Set false to keep it out of the bank config entirely — see A bank you shape yourself below
retainExtractionMode	"concise"	how the server extracts memories from sessions, commits and documents: "concise", "verbose", "verbatim" or "chunks" (store the text, no extraction). Every Stop writes the session back, so this is what each turn costs — "verbose" pulls more detail for several times the tokens. Kept in sync on the plugin's own retain strategies every session, so a change reaches existing banks too (not with manageBankConfig: false)
observationScopes	"shared"	how consolidation groups observations: "shared" (default) = ONE global scope per bank, so every agent on a repo builds one set of beliefs; also "combined" (the server default), "per_tag", "all_combinations", [["t"]]; "per_source" adds a scope per source: kind alongside the global one, so commit knowledge and conversation knowledge consolidate apart
disabled	false	hard off-switch (inert plugin/hook — a no-memory baseline)
reflectTimeoutMs	20000	automatic session-reflect timeout; on hook harnesses the installer registers a 30s prompt-hook timeout, so going above ~20s also means raising that hook's timeout in the host's config, or the host kills the ho

…