@adaptiqai/code 0.0.0-stage → 0.1.1

package/.claude-plugin/plugin.json

@@ -0,0 +1,12 @@
+{
+  "name": "adaptiqai-code",
+  "version": "0.1.0",
+  "description": "AdaptiqAI Code in Claude Code: the whole repository compiled into AdaptiqAI's memory and kept current from git, so the agent and every sub-agent ask it (code_ask, code_find, code_impact) instead of searching files.",
+  "author": {
+    "name": "AdaptiqAI",
+    "url": "https://adaptiqai.com"
+  },
+  "homepage": "https://adaptiqai.com",
+  "license": "UNLICENSED",
+  "keywords": ["adaptiqai", "repository", "codebase", "memory", "sub-agents"]
+}

package/.mcp.json

@@ -0,0 +1,10 @@
+{
+  "mcpServers": {
+    "adaptiqai-code": {
+      "command": "${CLAUDE_PLUGIN_ROOT}/bin/adaptiqai-code",
+      "args": [
+        "mcp"
+      ]
+    }
+  }
+}

package/DESIGN.md

@@ -0,0 +1,262 @@
+# AdaptiqAI Code: design and measurements
+
+AdaptiqAI Code compiles a whole git repository into AdaptiqAI's memory (an
+NCM collection), keeps it current from git, and lets a coding agent and its
+sub-agents ask it instead of searching files.
+
+## Modules
+
+Every capability is one contract in `src/kernel/types.ts` and one or more
+modules behind it, so a better method replaces a module and nothing else.
+
+| Contract | Module | What it does |
+| --- | --- | --- |
+| `RepoSource` | `source/git.ts` | Files of HEAD plus the working tree, blob ids (from git's index when unchanged, else `hash-object`), churn from `git log`. |
+| `FileFilter` | `filter/` | Binary, too large, lockfiles, generated, vendored, secrets (the whole file is kept out), `.adaptiqignore`, empty. |
+| `Layout` | `layout/churn.ts`, `layout/path.ts` | Compile order: stable files first, so edits land late in the causal chain. |
+| `Deriver` | `map/derive.ts` | `repo-map.md` (ranked definitions, Aider-style PageRank) and `relations.md` (imports, importers, tests), compiled with each rebuild. |
+| (planner) | `sync/plan.ts` | Pure: what to send. Append-only between rebuilds (below). |
+| `StateStore` | `sync/state.ts`, `sync/documents.ts` | Sync state and the compiled document list per worktree and model, in `.git/adaptiqai-code/`. |
+| `MemoryService` | `ncm/client.ts` | Collections over `/v1/memories`; sub-agent questions as chat turns in fresh helper sessions that include the collection. |
+| (sub-agents) | `swarm/` | Roles (explorer, relations, reviewer, planner, tests), parallel fan-out, questions routed to the code they name (`route.ts`: definitions and uses found on disk go with the question), answers grounded in the files on disk. |
+| `CodeApp` | `app.ts` | The facade every surface drives. |
+| surfaces | `mcp/`, `cli/`, `adapters/` | MCP server, CLI, Claude Code / Codex / Cursor / Continue / Pi adapters, git hooks. |
+
+The structure tools (`code_find`, `code_relations`, `code_impact`) answer from
+a graph built locally from the working tree: no model call, always current.
+
+## How it stays current
+
+A compiled memory is a causal chain: a change recompiles everything after it.
+Measured on the Qwen RTX pod (Qwen3.8-Flash-Next, 2026-10-31, 221k-token
+repository):
+
+| Change | Ready after |
+| --- | --- |
+| First compile | 74 s |
+| New text only at the end | 6.3 s |
+| An edit in the middle of the chain | 76 s (everything again) |
+| Base and an overlay as two collections | first question 84 s (the set compiled again) |
+| The changed file appended as a newer copy | 11.4 s |
+
+So between rebuilds a sync only appends: a changed file is added at the end
+as `<path> (updated n)` with a line saying it replaces every earlier copy, and
+deleted files are listed. The model chose the newer copy where the two
+disagree (6/6, including a conflicting constant). A rebuild compiles the
+repository afresh in the background (the old version serves until the new
+one is ready) when appended text passes 20% of the base, 40 appended
+documents, a branch change or seven days.
+
+Hooks: git `post-commit`, `post-merge`, `post-checkout` and `post-rewrite`,
+and the harness's edit events, start one debounced background sync.
+
+## Measured end to end (gateway, Qwen RTX)
+
+| | Result |
+| --- | --- |
+| `init` on this repository's 133 files (368k tokens) | 144 s |
+| One `code_ask` | 4.1 s |
+| 11 sub-agents at once | 26 s in all |
+| Where-is questions | 11/12 (the miss was a right file name in a wrong folder; grounding now corrects such paths) |
+| `git commit` of two changed files, synced by the hook | 13.9 s, both answered correctly |
+
+Pi on the same model, six lookups one search answers:
+
+| | Without | With the repository bound to every request |
+| --- | --- | --- |
+| Correct | 6/6 | 6/6 |
+| Time | 32.5 s | 89.9 s |
+| Tool calls | 22 | 18 |
+
+Binding the whole repository to every turn of the main agent costs each turn
+the restore of the memory, and the agent still searches. So the default is
+sub-agents on demand: the main agent's turns stay small and it asks the
+repository when a question needs it. Binding to every request is the
+`native` option.
+
+With that default, nine tasks (the six lookups and three that need several
+files):
+
+| | Without | Sub-agents on demand |
+| --- | --- | --- |
+| Correct | 8/9 | 8/9 |
+| Time | 61.5 s | 61.2 s |
+| Input tokens | 116k | 87k |
+| Tool calls | 36 | 37 |
+
+On a repository of 133 files one search usually finds the answer, so the
+gain is small. The case the design is for (large repositories, questions
+that cross many files, many sub-agents at once) is not measured yet.
+
+## A team in memory
+
+Agents on one repository share what they learn inside AdaptiqAI memory, not
+by pasting text into each other's prompts (`src/team/`).
+
+- **Members.** Every member is one session in memory. A member reads the
+  others' conversations (the newest, up to the link limit) from when it
+  joins, and every agent reads each member that joins after it. A sub-agent
+  answers once and never reads again, so no later member is linked into it,
+  and one that leaves the team is deleted from memory. A harness whose own
+  model runs on AdaptiqAI joins with its own session
+  (`adaptiqai-code team join --session <id>`); a harness whose model does not
+  (Claude Code) gets a session that stands for it.
+- **Telling the team.** `code_note` is a turn in the agent's own session; the
+  others read it from memory seconds later.
+- **Asking.** `code_ask` and `code_fanout` sub-agents read the repository and
+  every member's conversation, so they know what any member was told or found.
+- **Fusion.** A planner splits a task. The sub-agents for its parts join the
+  team in one round: each reads the conversations the planner read, in the
+  same order, so the engine compiles what they read once for all of them,
+  and no link changes it during their turns. They answer in parallel, and an
+  answer is in its conversation when its turn ends (the engine takes it in
+  then, MrRopke/adaptiq-vllm#271). A lead, linked to the asker and the
+  sub-agents while they work, asks once they answered; meanwhile the team
+  links to the new sub-agents. With depth above 1 a part runs as a fusion of
+  its own. The newest 8 sub-agents stay in the team; older ones leave and
+  free their links (a session reads at most 16 others).
+
+Measured on a Qwen RTX test pod (EUR-IS-1, never on the gateway; the
+production build plus links both ways, MrRopke/adaptiq-vllm#269; the model's
+own settings and a 5,000,000-token context):
+
+| | Result |
+| --- | --- |
+| Agent B reads agent A's conversation | correct, 3.7 s |
+| A fact told to A, then asked of B | correct on the first try, 3.4 s after |
+| Five agents, all linked to all, each told one fact, each asked the four others' | 20/20, round 15.6 s (warm) |
+| Through the plugin: a note from one Claude Code session, asked from another | correct, note 3.1 s, answer 7.3 s |
+| Fusion: planner, 4 parallel sub-agents, lead reading them and the team's note | answered, with the note's facts, 6 sessions in 232.8 s |
+
+In the real harness: two DeepSeek Harness sessions on the production gateway
+(`adaptiq-qwen3.8-flash-next`, the model's own settings, 2026-11-01), each
+joined by the plugin's SessionStart hook. One was told a short story in its
+chat, and the other was asked right after:
+
+| | Facts right | The asked agent's turn |
+| --- | --- | --- |
+| dsh A told, dsh B asked (5 rounds both ways) | 26/26 | 32.3-83.2 s |
+| Four earlier dsh rounds, members joined by hand | 21/21 | 32.7-68.6 s |
+| Claude Code told (it called code_note), dsh A asked | 6/6 | 99.6 s |
+| dsh A told, Claude Code asked (it called code_ask) | 5/5 | 102.6 s |
+
+The time goes to the engine: the asked agent's request gets `425
+AdaptiqMemoryNotReady ... (compiling 0/3184 tokens)` while the one new block
+of the linked conversation waits in the compile queue (7-89 s here, with
+other compiles on the same engine), then 2-46 s to the first token. The test
+pod, with nothing else compiling, took 2.6-4 s.
+
+Fusion before and after on the production gateway (Qwen RTX,
+`adaptiq-qwen3.8-flash-next`, the model's own settings, 2026-11-01). This
+repository (720k tokens, one collection) and seven fusion tasks with checked
+answers (`scripts/fusion-check.ts`). Each task ran on main and on this design
+back to back on the same engine build, each with its own team. Runs that a
+gateway or engine outage broke are left out (main's compaction):
+
+| Task | Main | This design |
+| --- | --- | --- |
+| retry425 | 125 s, wrong | 483 s, right |
+| links | 1,064 s, wrong | 693 s, right |
+| rebuild | 724 s, wrong | 242 s, right |
+| thinking | 809 s, right | 169 s, right |
+| filters | 166 s, wrong | 351 s, wrong |
+| compaction | (outage) | 321 s, wrong |
+| teamfile | 389 s, wrong | 808 s, wrong |
+| Right | 1/6 | 4/7 |
+| Mean, median | 546 s, 556 s | 438 s, 351 s |
+
+Where the time went, mean per fusion:
+
+| Phase | Main | This design |
+| --- | --- | --- |
+| Sub-agents' longest wait for their set (425) | 16.7 s | 0 s |
+| Seal turns after the parts | 10.1 s | none |
+| Planner's wait for its set | 0 s | 3.8 s |
+| Lead's wait for its set | 7.1 s | 9.0 s |
+| Tokens the model wrote (thinking and answers) | 38.0k | 36.0k |
+| Link requests | 34 | 28 |
+
+Most of a fusion is the model thinking: 36-38k tokens at 28-144 tokens/s,
+depending on the engine's load. A lower thinking level for the planner, the
+parts or the lead was faster (82 s against 231 s on one task) but did not
+keep the answers right, so thinking stays as the model ships.
+
+What it took: the planner and the lead think as the model ships (with
+thinking off the planner stopped before its JSON when the repository was in
+memory; with its lowest level it split a task into one part and the answer
+missed a fact). The engine compiles what a session reads as one set per
+list of conversations in link order, so the planner and its sub-agents link
+the same conversations in the same order, one at a time, and share one
+compile. A question waits for its first byte up to the plugin's own
+10-minute limit, not Node's 300 s.
+
+## Precision: nothing named that is not there
+
+An agent acts on the paths and symbols an answer names, so one invented file
+breaks its trust. What keeps an answer to what exists:
+
+- **Grounding** (`swarm/ground.ts`, no model call). Every path is checked
+  against the working tree, dotfiles (`.npmrc`) and dot-folders included. A
+  wrong folder for a file name found once is corrected, except in a sentence
+  that says it is not there ("there is no `packages/code/.npmrc`" stays as
+  written). A path no file has and no file names (`.adaptiq/code.json` is
+  named by the code, so it stands) is marked "(not in the repository)", a
+  code symbol the repository never mentions "(not found in the repository)",
+  a line past a file's end "(no line N: it has M)". Code blocks are left as
+  written.
+- **Prompts** (`swarm/roles.ts`). "This repository has no such file" is a
+  complete answer; a path must be one seen as a document name; a linked
+  conversation is never a file; no tools, never "I'll search"; the question's
+  own answer form goes first.
+- **The file list** (`repo-map.md`, "Every file"). Every compiled file by
+  folder, within a third of the map's budget (1.7k tokens for 336 files), so
+  a sub-agent that reads only part of the repository still knows what exists.
+  Without it, answers denied files that are there.
+- **An empty answer is an error.** The model sometimes answers with a tool
+  call it was never offered; the server drops it and returns no text with
+  finish "stop" (measured: 5 of 8 tries of one question, 6 of 49 in a run).
+
+The precision set (`bench/precision/`, 49 questions with the truth from the
+code, 10 of them traps whose honest answer is "not here") is scored against
+the checkout's files. Measured on the gateway, Qwen RTX installer set
+2d67444d, one collection of the set's 127 files, each answer read by hand as
+well:
+
+| | Correct | Wrong | Invented | Unanswered |
+| --- | --- | --- | --- | --- |
+| Before (main d6ee785) | 43 | 2 | 4 | 0 |
+| After | 48 | 0 | 1 | 0 |
+
+Before, the inventions were a file (`packages/code/src/sync/sync.ts`), two
+symbols and a claimed `eslint.config.js`; the wrong answers denied files that
+exist (`pnpm-workspace.yaml`, the CI workflows). After, the one miss put the
+root `.npmrc` in `packages/code` in prose, as no path grounding could check.
+On the earlier main (81fc117, thinking off, installer set 332113e2) the same
+set went from 42 correct and 6 unanswered to 49 correct.
+
+The `.npmrc` that started this was no invented file: `.npmrc` exists and was
+the first document compiled. The model put a teammate's note, said in a
+linked conversation, in that file ("recorded in `.npmrc`'s conversation",
+"open `.npmrc`, the note itself"). The same probe (`team-probe.ts`, three
+tries) put the note in a workflow file 2 of 3 times on 81fc117; after, 0 of 3,
+and the file the note names is no longer denied (3 of 3 before on d6ee785,
+0 of 3 after).
+
+## Known limits
+
+- A sub-agent reads a selected working set of a large repository per
+  question (130k of 372k tokens here), not all of it at once.
+- Grounding sees a path only when it is written as one: "the `.npmrc` is in
+  `packages/code`" names no path to check.
+- An app a person signed in (`adaptiqai-code login`, the dsh sign-in) may
+  write at most 64 sources and 8 MB at once, so a larger list goes as packs
+  of files of up to 128 KB, in order (an append changes only the last pack).
+  A repository past 8 MB of text needs `.adaptiqignore`.
+- In DeepSeek Harness the MCP server starts in the folder dsh started in, so
+  the code_* tools serve that repository; the team hooks follow each
+  session's own folder.
+- A rebuild costs a full compile; an engine change that adopts the longest
+  unchanged prefix at any point (with recurrent snapshots along knowledge
+  tapes) would make it cheap.
+- Usage: a seeded collection's prefix was billed as new input (242,200 tokens
+  per question); the engine fix counts it as a memory read.

package/README.md

@@ -1,3 +1,123 @@
-# Temporary Holding Version
+# AdaptiqAI Code
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Your whole git repository, compiled into AdaptiqAI's model memory and kept
+current from git. Your coding agent and every sub-agent it starts ask the
+repository instead of grepping and opening files one by one: where something
+is, how parts connect, what a change would break.
+
+```bash
+npm install -g @adaptiqai/code
+cd your-repository
+adaptiqai-code init
+```
+
+`init` compiles the repository (the first time takes a while; later syncs
+only send what changed), turns AdaptiqAI Code on for this repository, sets up
+the coding agents it finds on this computer, and adds the git hooks that keep
+the memory current.
+
+AdaptiqAI Code uses this computer's AdaptiqAI sign-in, the same one the
+AdaptiqAI MCP app uses, or `ADAPTIQAI_API_KEY` when it is set.
+`adaptiqai-code login` signs in in the browser.
+
+## Your coding agent
+
+One command each, run in the repository. `init` already ran the ones for the
+agents it found.
+
+| Agent | Command | What it sets up |
+|---|---|---|
+| Claude Code | `adaptiqai-code install claude` | Hooks in `.claude/settings.local.json`, the MCP server in `.mcp.json` |
+| Codex CLI | `adaptiqai-code install codex` | Hooks in `~/.codex/hooks.json`, the MCP server in `~/.codex/config.toml` |
+| Cursor | `adaptiqai-code install cursor` | Hooks in `.cursor/hooks.json`, the MCP server in `.cursor/mcp.json` |
+| Continue | `adaptiqai-code install continue` | A rule in `.continue/rules/`, the MCP server in `.continue/mcpServers/` |
+| Pi | `adaptiqai-code install pi` | An extension in `.pi/extensions/` |
+| DeepSeek Harness | `adaptiqai-code install dsh [--profile <name>]` | One block in each profile's `cordis.patch.yml` (the MCP server and the hooks, through dsh's own MCP client and Claude Code hook bridge), the hooks in `~/.dsh/adaptiqai-code/hooks.json` |
+
+Claude Code can instead take the package as a plugin (it carries
+`.claude-plugin/plugin.json`, `hooks/hooks.json` and `.mcp.json`); with the
+plugin installed, `install claude` adds nothing, so nothing runs twice. The
+plugin starts `node`, so Node.js 22 or newer has to be on Claude Code's PATH.
+
+Your own settings in these files stay as they are: AdaptiqAI Code adds its
+entries beside them and `adaptiqai-code uninstall` takes out only its own.
+Files it creates in the repository are listed in `.git/info/exclude`, so
+they never show up in `git status`.
+
+What the agent gets:
+
+- **At session start**, a short brief of the repository (what it is, how it
+  is laid out, what changed since the last sync).
+- **Tools**: `code_ask` (a sub-agent that has the whole repository in memory
+  answers, with `path:line`), `code_fanout` (up to 16 questions at once, in
+  parallel), `code_find` (where a symbol is defined, instantly),
+  `code_relations` (imports, importers, tests), `code_impact` (what depends on
+  a set of files), `code_status` and `code_sync`.
+- **Sub-agents** are told they share the same memory, and are asked as
+  helpers of the session that started them.
+
+## A team that learns together
+
+Every agent on the repository can be in one team in AdaptiqAI memory: each
+reads the others' conversations, so what one learns, the others know seconds
+later.
+
+- `code_note` (or `adaptiqai-code note "<title>" "<text>"`): tell the team.
+- `code_fusion` (or `adaptiqai-code fusion "<task>"`): a team of sub-agents
+  works on one task in parallel; a lead answers from what they found.
+- `adaptiqai-code team join --session <id> --name <role>`: add an agent whose
+  own model runs on AdaptiqAI, with its own conversation.
+- DeepSeek Harness does that by itself: each session on an AdaptiqAI model
+  joins the team with its own conversation when it starts, so what one
+  session is told, another answers from memory. A session that joins again
+  gets back any link a failure left out.
+- `code_team` / `adaptiqai-code team`: who is in the team.
+
+## How it stays current
+
+- After the agent edits a file, the hook tells the memory which file changed.
+- After a commit, merge, checkout, rebase or amend, the git hooks sync. A hook
+  that was already there keeps running first; `uninstall git` puts it back.
+- Syncs run in the background and are debounced: a burst of edits or a long
+  rebase becomes one sync.
+- When a session starts with files changed since the last sync, a sync is
+  queued first (for at most 3 seconds; it never holds the session up).
+
+Hooks never break your agent: if anything goes wrong they print nothing and
+exit 0. `adaptiqai-code doctor` says what is wrong.
+
+## Commands
+
+| Command | |
+|---|---|
+| `adaptiqai-code init [--harness=claude,codex,...] [--no-git-hooks]` | Compile, turn on, set up agents and git hooks |
+| `adaptiqai-code sync [--full] [--background]` | Sync now (`--full` rebuilds everything) |
+| `adaptiqai-code status` | Where the memory stands: commit, files, tokens, what changed since |
+| `adaptiqai-code ask "<question>" [--role <role>]` | Ask the repository from the terminal |
+| `adaptiqai-code fanout "<question>" "<question>"...` | Several questions at once |
+| `adaptiqai-code find <name>` | Where a symbol is defined |
+| `adaptiqai-code relations <path>` | How a file connects to the rest |
+| `adaptiqai-code impact <path...>` | What depends on these files |
+| `adaptiqai-code brief` | The brief agents get at session start |
+| `adaptiqai-code roles` | The roles a sub-agent can answer in |
+| `adaptiqai-code install <agent...>` / `uninstall [<agent...>]` | Add or take out one agent, or `git` |
+| `adaptiqai-code login` | Sign this computer in to AdaptiqAI |
+| `adaptiqai-code doctor` | Check git, sign-in, model, hooks and the last sync |
+
+Most commands take `--json`. `--root <dir>` names another repository.
+`mcp` and `hook <agent> <event>` are what the agents' configs start.
+
+## Privacy
+
+- Nothing is sent from a repository until you run `init` there. The hooks and
+  the MCP server do nothing in any other repository, even when an agent is set
+  up for every repository (Codex) or as a plugin (Claude Code).
+  `git config adaptiqai-code.enabled` shows whether a repository is on;
+  `adaptiqai-code uninstall` turns it off.
+- Files git ignores are never read. Binary files, lockfiles, generated and
+  vendored code are left out.
+- A file that holds a credential (a private key, a token, a password
+  assignment) is left out whole.
+- To keep more out, list it in `.adaptiqignore` at the repository root, in
+  `.gitignore` syntax; a `!` rule there takes a file back in.
+- `adaptiqai-code status` says how many files were left out, and why.

package/bin/adaptiqai-code

@@ -0,0 +1,50 @@
+#!/bin/sh
+# AdaptiqAI Code as the Claude Code plugin starts it (its MCP server and hooks), through
+# /bin/sh, so a package that lost its file modes still starts (npx runs
+# lib/index.js itself). Claude Code needs no Node.js of its own, and one
+# started from the Dock or a menu often runs without the PATH a terminal gets
+# from nvm, fnm, Volta, asdf, mise or Homebrew, so a Node.js 22 or newer is
+# looked for there too, or ADAPTIQAI_NODE names one. With none, the server
+# still answers, with no tools and instructions that say why: the agent can
+# tell the person, where a server that fails to start says nothing. A hook
+# without Node.js does nothing, so the harness is never held up.
+root=$(cd "$(dirname "$0")/.." && pwd)
+
+usable() {
+  [ -n "$1" ] && [ -x "$1" ] && "$1" -e 'process.exit(+process.versions.node.split(".")[0] >= 22 ? 0 : 1)' >/dev/null 2>&1
+}
+
+if [ -n "${ADAPTIQAI_NODE:-}" ]; then
+  usable "$ADAPTIQAI_NODE" && exec "$ADAPTIQAI_NODE" "$root/lib/index.js" "$@"
+else
+  for node in "$(command -v node 2>/dev/null)" \
+    "${VOLTA_HOME:-$HOME/.volta}/bin/node" \
+    "${FNM_DIR:-$HOME/.local/share/fnm}/aliases/default/bin/node" \
+    "$HOME/Library/Application Support/fnm/aliases/default/bin/node" \
+    "$HOME/.asdf/shims/node" "$HOME/.local/share/mise/shims/node" \
+    /opt/homebrew/bin/node /usr/local/bin/node /usr/bin/node \
+    "${NVM_DIR:-$HOME/.nvm}"/versions/node/*/bin/node; do
+    usable "$node" && exec "$node" "$root/lib/index.js" "$@"
+  done
+fi
+
+reason='AdaptiqAI Code is not available here: it needs Node.js 22 or newer on this computer, and the Claude Code plugin found none. When the repository memory would help, tell the person to install Node.js 22 or newer (nodejs.org), or to set ADAPTIQAI_NODE to one in the env of Claude Code'"'"'s settings, and then to start Claude Code again.'
+echo "adaptiqai-code: $reason" >&2
+# Only the MCP server answers; a hook prints nothing and exits.
+[ "${1:-}" = mcp ] || exit 0
+while IFS= read -r line || [ -n "$line" ]; do
+  id=$(printf '%s\n' "$line" | sed -nE 's/.*"id":("[^"]*"|-?[0-9]+).*/\1/p')
+  # A notification has no id and gets no answer.
+  [ -n "$id" ] || continue
+  case $line in
+    *'"method":"initialize"'*)
+      version=$(printf '%s\n' "$line" | sed -nE 's/.*"protocolVersion":"([^"]*)".*/\1/p')
+      result="{\"protocolVersion\":\"${version:-2025-06-18}\",\"capabilities\":{\"tools\":{}},\"serverInfo\":{\"name\":\"adaptiqai-code\",\"title\":\"AdaptiqAI Code\",\"version\":\"0.0.0\"},\"instructions\":\"$reason\"}" ;;
+    *'"method":"tools/list"'*) result='{"tools":[]}' ;;
+    *'"method":"ping"'*) result='{}' ;;
+    *)
+      printf '{"jsonrpc":"2.0","id":%s,"error":{"code":-32601,"message":"Method not found"}}\n' "$id"
+      continue ;;
+  esac
+  printf '{"jsonrpc":"2.0","id":%s,"result":%s}\n' "$id" "$result"
+done

package/hooks/hooks.json

@@ -0,0 +1,41 @@
+{
+  "description": "AdaptiqAI Code: the repository's brief at session start, edited files synced into memory, sub-agents told they share it.",
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume|clear|compact",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/bin/adaptiqai-code\" hook claude SessionStart",
+            "timeout": 15
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write|MultiEdit|NotebookEdit|Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/bin/adaptiqai-code\" hook claude PostToolUse",
+            "async": true,
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "SubagentStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/bin/adaptiqai-code\" hook claude SubagentStart",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}