memgraph-context-graph 0.7.4__tar.gz → 0.9.0__tar.gz

{memgraph_context_graph-0.7.4 → memgraph_context_graph-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memgraph-context-graph
-Version: 0.7.4
+Version: 0.9.0
 Summary: Connect agent SDKs to context-graph components (actions-graph, skills-graph, etc.)
 License: MIT
 License-File: LICENSE
@@ -202,6 +202,7 @@ memgraph-context-graph setup                     # interactive on a terminal; pl
 memgraph-context-graph setup claude-code codex   # just these agents
 memgraph-context-graph setup cursor --project-dir ~/work/billing
 memgraph-context-graph setup --plan              # print the plan, change nothing
+memgraph-context-graph update [runtime ...]      # upgrade the package, refresh the wiring and the schema
 memgraph-context-graph uninstall [runtime ...]   # remove the wiring; the graph and config stay
 ```
 
@@ -211,6 +212,15 @@ wires each agent, and runs `doctor`'s checks. Every step checks before it acts,
 missing. The TUI starts only when stdin and stdout are both terminals; the plugins' `scripts/bootstrap.sh`
 runs `setup <runtime> --no-tui`.
 
+**Updating.** Upgrading the package moves the code hooks and the MCP server run, but what setup wrote once stays
+as it was. `update` upgrades the uv tool and its connectors, then, with the new release, refreshes everything
+that is wired: Claude Code's and Codex's plugin (marketplace refreshed, plugin updated), each per-project agent's
+hook file in `--project-dir` (default: the current directory) and its MCP registration, and the graph's indexes
+and constraints. It then runs `doctor`'s checks. Name runtimes to refresh only those; `--no-upgrade` skips the
+package step. Your own hooks, the config and the graph's data are untouched, and running it again changes nothing.
+Running agent sessions keep the hooks they loaded: restart them. Outside the uv tool (a virtualenv, say) the
+package step only warns, and you upgrade it yourself first.
+
 **Identity and connection.** setup writes `~/.config/context-graph/config.toml`; hooks read their configuration from that file at runtime (see [Configuration](#configuration) — env vars are **not** read at hook time). To change your identity later:
 
 ```bash
@@ -268,6 +278,10 @@ database = "memgraph"
 [llm]
 openai_api_key = ""
 anthropic_api_key = ""
+derive_model = "claude-sonnet-5-5"
+
+[capture]
+connectors = "skills-graph, actions-graph, sessions-graph"
 
 [reconcile]
 auto_reconcile = true
@@ -275,12 +289,21 @@ auto_reconcile = true
 [recall]
 embedding_model = "BAAI/bge-small-en-v1.5"
 turns_k = "8"
+
+[extraction]
+model = "fastino/gliner2.5-base-v1"
+entity_threshold = "0.3"
 ```
 
 `[reconcile]` turns on sessions-graph's auto-trigger reconciliation (see
 [sessions-graph § reconciliation](../sessions-graph/README.md#session-reconciliation)),
 which needs no LLM. `[llm]` is optional: a key only lets reconciliation learn
-the user's own ontology (`sessions-graph derive`).
+the user's own ontology (`sessions-graph derive`), and `derive_model` picks
+the model it calls (default `claude-sonnet-5-5` with Anthropic, `gpt-5` with OpenAI).
+`[capture] connectors` is which graph connectors a hook enables when its
+command names no `--connector`, from `skills-graph`, `actions-graph`,
+`sessions-graph` and `resources-graph`; unset means the first three, and
+an empty value enables none. Setup installs the ones it names.
 `[reconcile]` is omitted entirely from a file setup wrote — absent
 means "never configured," distinct from an explicit `auto_reconcile = false`.
 `[recall]` is optional too: without it, recall runs with the widths the
@@ -288,6 +311,10 @@ benchmark measured; see [Recall](#recall-memory-for-the-harnesss-model).
 `[ontology]` is optional as well: `path` names a schema file the user's
 sessions are extracted under and `derive` is `extend` (the default) or
 `off`; see sessions-graph's [Ontology versions](../sessions-graph/README.md#ontology-versions).
+`[extraction]` tunes how reconciliation, re-extraction and derivation read
+sessions, all optional: `model` (a GLiNER2 checkpoint), `entity_threshold` and
+`relation_threshold` (drop extractions below that confidence, 0 to 1), and
+`chunk_size`/`chunk_overlap` (words per window); unset keys keep GLiNER2's defaults.
 
 Manage it with:
 
@@ -296,8 +323,9 @@ memgraph-context-graph config show
 memgraph-context-graph config get memgraph.url
 memgraph-context-graph config set <key> <value>
 # keys: identity.user_id, memgraph.{url,user,password,database},
-#       llm.{openai_api_key,anthropic_api_key}, reconcile.auto_reconcile,
-#       recall.embedding_model, ontology.{path,derive}, memory.backend
+#       llm.{openai_api_key,anthropic_api_key,derive_model}, capture.connectors,
+#       reconcile.auto_reconcile, recall.embedding_model, ontology.{path,derive}, memory.backend
+# [recall] widths and [extraction] are edited in the file.
 ```
 
 Hooks never read environment variables for these values, and neither does setup: it writes only
@@ -308,15 +336,23 @@ Hooks never read environment variables for these values, and neither does setup:
 
 The hooks write sessions into Memgraph; recall reads them back. With
 sessions-graph installed, `memgraph-context-graph mcp` serves a `recall(question)`
-tool over stdio MCP, and the Codex and Claude Code plugins bundle that server,
-so installing a plugin is all it takes. The tool returns context, not an answer:
+tool over stdio MCP. The Codex and Claude Code plugins bundle that server, so
+installing a plugin is all it takes; for the other agents, `setup` registers it
+in each one's own user-level MCP config (see
+[every agent](#every-agent-registration-switch-and-session-start)). The tool returns context, not an answer:
 the dated messages and facts from the user's own sessions that match the
 question, behind a header with the rules for reading them. The harness's model
 answers from those rows.
 
-At session start the hook adds one line to the model's context saying the tool
-exists. It never pushes retrieved content; the model calls `recall` when a
-question needs memory.
+At session start the hook adds a line to the model's context saying the tool
+exists, then where the user left off in this project: the last session's date,
+agent, first and last ask and last reply, and the first ask of the two before
+it, quoted from captured turns. Sessions from any agent count, so a session in
+Grok picks up where one in Codex stopped. It is a pointer, not a recall result:
+nothing is ranked against a question, and the model still calls `recall` when
+one needs memory. A session's project is its checkout's key (the same one
+memory folders use), recorded when it starts. Turn it off with
+`memgraph-context-graph config set session_start.resume false`.
 
 A connector may also add a line just before a tool runs
 (`GraphConnector.context_before_tool`) — resources-graph's Nudge that what the
@@ -347,6 +383,7 @@ from the tool call, so a model can only read its own user's sessions.
 | `facts_k`, `fact_turns_k` | `15`, `8` | Facts matched, and the messages they were read from |
 | `user_fact_types`, `user_facts_k` | `2`, `30` | Relation types gathered whole, for counting questions |
 | `turn_chars` | `1500` | Characters shown per message |
+| `query_instruction` | per model | Prefix embedded with the question; bge's English models get their retrieval instruction, other models none |
 
 Recall needs Memgraph with MAGE (`memgraph/memgraph-mage`) for its vector lanes;
 without it, it answers from text search and says so. `doctor` checks both
@@ -359,8 +396,9 @@ was benchmarked in; the JSON is what `--json` prints.
 
 ### Memory: Context Graph as the harness's memory
 
-Claude Code and Codex each keep their own memory. Context Graph can replace it
-for a user who opts in:
+Every agent `setup` knows can use Context Graph as its memory. Claude Code and
+Codex each keep their own memory, and Context Graph replaces it for a user who
+opts in:
 
 ```bash
 memgraph-context-graph setup claude-code --memory-backend context-graph
@@ -431,6 +469,34 @@ name is used. See
 [ADR 0006](docs/adr/0006-memory-tool-writes-explicit-memory.md) for why this is
 the one write the model makes over MCP.
 
+#### Every agent: registration, switch and session start
+
+The other five have no plugin, so `setup <runtime>` registers the
+`context-graph` MCP server in the agent's own user-level config: memory belongs
+to the user, not to one project. It adds the server's tools to the agent's
+persistent allow-list where it keeps one, because a headless run refuses a tool
+that needs approval. `--memory-backend context-graph` then turns the agent's
+own memory off, and `uninstall` undoes both. Every edited file keeps the rest of
+its content and is backed up once to `<name>.context-graph.bak`.
+
+| Agent | Built-in memory, and the switch | Server registered in | Session-start text reaches the model through |
+|---|---|---|---|
+| Claude Code | auto memory; `autoMemoryEnabled: false` | the plugin | `SessionStart` `additionalContext` |
+| Codex | memories; three keys in `config.toml` | the plugin | `SessionStart` `additionalContext` (~2,500-token cap) |
+| Copilot CLI | Copilot Memory (on GitHub, not importable); `"memory": false` in `~/.copilot/settings.json` | `~/.copilot/mcp-config.json` (no allow-list: approve once, or `--allow-tool=context-graph`) | `sessionStart` top-level `additionalContext` |
+| Cursor | none (Memories was removed) | `~/.cursor/mcp.json`; allow `Mcp(context-graph:*)` in `~/.cursor/cli-config.json` | `sessionStart` `additional_context` (the IDE's agent window can drop it; untested here) |
+| OpenCode | none | `mcp.servers` in `~/.config/opencode/opencode.json`, `codemode: false`; an allow rule in `permissions` | the plugin's `context` hook, added to the system prompt of every request |
+| Antigravity CLI | none (Knowledge is off in the CLI) | `~/.gemini/config/mcp_config.json`; allow `mcp(context-graph/*)` in `~/.gemini/antigravity-cli/settings.json` | `SessionStart` `injectSteps` system message |
+| Grok Build | topic notes under `~/.grok/memory-v2/`, imported to `/memories/grok/`; `[memory_v2] enabled = false` | `~/.grok/config.toml`; allow `MCPTool(context-graph__*)` | the MCP server's `instructions` (`mcp --session-context`): Grok's start hooks can't reach the model |
+
+Antigravity's hooks carry no prompt or reply text, so its turns are read from
+the transcript its `Stop` payload points at; that is what gives its sessions a
+place in recall and in the next session's "where you left off".
+
+`live-hooks-e2e.sh memory` checks this against each installed agent: a memory
+written, one read back in a new session, and the next session's index and last
+ask.
+
 ### Codex and Claude Code Plugins
 
 Both runtimes have a distributable Runtime Plugin that wires hooks and the MCP server; marketplace

{memgraph_context_graph-0.7.4 → memgraph_context_graph-0.9.0}/README.md

@@ -177,6 +177,7 @@ memgraph-context-graph setup                     # interactive on a terminal; pl
 memgraph-context-graph setup claude-code codex   # just these agents
 memgraph-context-graph setup cursor --project-dir ~/work/billing
 memgraph-context-graph setup --plan              # print the plan, change nothing
+memgraph-context-graph update [runtime ...]      # upgrade the package, refresh the wiring and the schema
 memgraph-context-graph uninstall [runtime ...]   # remove the wiring; the graph and config stay
 ```
 
@@ -186,6 +187,15 @@ wires each agent, and runs `doctor`'s checks. Every step checks before it acts,
 missing. The TUI starts only when stdin and stdout are both terminals; the plugins' `scripts/bootstrap.sh`
 runs `setup <runtime> --no-tui`.
 
+**Updating.** Upgrading the package moves the code hooks and the MCP server run, but what setup wrote once stays
+as it was. `update` upgrades the uv tool and its connectors, then, with the new release, refreshes everything
+that is wired: Claude Code's and Codex's plugin (marketplace refreshed, plugin updated), each per-project agent's
+hook file in `--project-dir` (default: the current directory) and its MCP registration, and the graph's indexes
+and constraints. It then runs `doctor`'s checks. Name runtimes to refresh only those; `--no-upgrade` skips the
+package step. Your own hooks, the config and the graph's data are untouched, and running it again changes nothing.
+Running agent sessions keep the hooks they loaded: restart them. Outside the uv tool (a virtualenv, say) the
+package step only warns, and you upgrade it yourself first.
+
 **Identity and connection.** setup writes `~/.config/context-graph/config.toml`; hooks read their configuration from that file at runtime (see [Configuration](#configuration) — env vars are **not** read at hook time). To change your identity later:
 
 ```bash
@@ -243,6 +253,10 @@ database = "memgraph"
 [llm]
 openai_api_key = ""
 anthropic_api_key = ""
+derive_model = "claude-sonnet-5-5"
+
+[capture]
+connectors = "skills-graph, actions-graph, sessions-graph"
 
 [reconcile]
 auto_reconcile = true
@@ -250,12 +264,21 @@ auto_reconcile = true
 [recall]
 embedding_model = "BAAI/bge-small-en-v1.5"
 turns_k = "8"
+
+[extraction]
+model = "fastino/gliner2.5-base-v1"
+entity_threshold = "0.3"
 ```
 
 `[reconcile]` turns on sessions-graph's auto-trigger reconciliation (see
 [sessions-graph § reconciliation](../sessions-graph/README.md#session-reconciliation)),
 which needs no LLM. `[llm]` is optional: a key only lets reconciliation learn
-the user's own ontology (`sessions-graph derive`).
+the user's own ontology (`sessions-graph derive`), and `derive_model` picks
+the model it calls (default `claude-sonnet-5-5` with Anthropic, `gpt-5` with OpenAI).
+`[capture] connectors` is which graph connectors a hook enables when its
+command names no `--connector`, from `skills-graph`, `actions-graph`,
+`sessions-graph` and `resources-graph`; unset means the first three, and
+an empty value enables none. Setup installs the ones it names.
 `[reconcile]` is omitted entirely from a file setup wrote — absent
 means "never configured," distinct from an explicit `auto_reconcile = false`.
 `[recall]` is optional too: without it, recall runs with the widths the
@@ -263,6 +286,10 @@ benchmark measured; see [Recall](#recall-memory-for-the-harnesss-model).
 `[ontology]` is optional as well: `path` names a schema file the user's
 sessions are extracted under and `derive` is `extend` (the default) or
 `off`; see sessions-graph's [Ontology versions](../sessions-graph/README.md#ontology-versions).
+`[extraction]` tunes how reconciliation, re-extraction and derivation read
+sessions, all optional: `model` (a GLiNER2 checkpoint), `entity_threshold` and
+`relation_threshold` (drop extractions below that confidence, 0 to 1), and
+`chunk_size`/`chunk_overlap` (words per window); unset keys keep GLiNER2's defaults.
 
 Manage it with:
 
@@ -271,8 +298,9 @@ memgraph-context-graph config show
 memgraph-context-graph config get memgraph.url
 memgraph-context-graph config set <key> <value>
 # keys: identity.user_id, memgraph.{url,user,password,database},
-#       llm.{openai_api_key,anthropic_api_key}, reconcile.auto_reconcile,
-#       recall.embedding_model, ontology.{path,derive}, memory.backend
+#       llm.{openai_api_key,anthropic_api_key,derive_model}, capture.connectors,
+#       reconcile.auto_reconcile, recall.embedding_model, ontology.{path,derive}, memory.backend
+# [recall] widths and [extraction] are edited in the file.
 ```
 
 Hooks never read environment variables for these values, and neither does setup: it writes only
@@ -283,15 +311,23 @@ Hooks never read environment variables for these values, and neither does setup:
 
 The hooks write sessions into Memgraph; recall reads them back. With
 sessions-graph installed, `memgraph-context-graph mcp` serves a `recall(question)`
-tool over stdio MCP, and the Codex and Claude Code plugins bundle that server,
-so installing a plugin is all it takes. The tool returns context, not an answer:
+tool over stdio MCP. The Codex and Claude Code plugins bundle that server, so
+installing a plugin is all it takes; for the other agents, `setup` registers it
+in each one's own user-level MCP config (see
+[every agent](#every-agent-registration-switch-and-session-start)). The tool returns context, not an answer:
 the dated messages and facts from the user's own sessions that match the
 question, behind a header with the rules for reading them. The harness's model
 answers from those rows.
 
-At session start the hook adds one line to the model's context saying the tool
-exists. It never pushes retrieved content; the model calls `recall` when a
-question needs memory.
+At session start the hook adds a line to the model's context saying the tool
+exists, then where the user left off in this project: the last session's date,
+agent, first and last ask and last reply, and the first ask of the two before
+it, quoted from captured turns. Sessions from any agent count, so a session in
+Grok picks up where one in Codex stopped. It is a pointer, not a recall result:
+nothing is ranked against a question, and the model still calls `recall` when
+one needs memory. A session's project is its checkout's key (the same one
+memory folders use), recorded when it starts. Turn it off with
+`memgraph-context-graph config set session_start.resume false`.
 
 A connector may also add a line just before a tool runs
 (`GraphConnector.context_before_tool`) — resources-graph's Nudge that what the
@@ -322,6 +358,7 @@ from the tool call, so a model can only read its own user's sessions.
 | `facts_k`, `fact_turns_k` | `15`, `8` | Facts matched, and the messages they were read from |
 | `user_fact_types`, `user_facts_k` | `2`, `30` | Relation types gathered whole, for counting questions |
 | `turn_chars` | `1500` | Characters shown per message |
+| `query_instruction` | per model | Prefix embedded with the question; bge's English models get their retrieval instruction, other models none |
 
 Recall needs Memgraph with MAGE (`memgraph/memgraph-mage`) for its vector lanes;
 without it, it answers from text search and says so. `doctor` checks both
@@ -334,8 +371,9 @@ was benchmarked in; the JSON is what `--json` prints.
 
 ### Memory: Context Graph as the harness's memory
 
-Claude Code and Codex each keep their own memory. Context Graph can replace it
-for a user who opts in:
+Every agent `setup` knows can use Context Graph as its memory. Claude Code and
+Codex each keep their own memory, and Context Graph replaces it for a user who
+opts in:
 
 ```bash
 memgraph-context-graph setup claude-code --memory-backend context-graph
@@ -406,6 +444,34 @@ name is used. See
 [ADR 0006](docs/adr/0006-memory-tool-writes-explicit-memory.md) for why this is
 the one write the model makes over MCP.
 
+#### Every agent: registration, switch and session start
+
+The other five have no plugin, so `setup <runtime>` registers the
+`context-graph` MCP server in the agent's own user-level config: memory belongs
+to the user, not to one project. It adds the server's tools to the agent's
+persistent allow-list where it keeps one, because a headless run refuses a tool
+that needs approval. `--memory-backend context-graph` then turns the agent's
+own memory off, and `uninstall` undoes both. Every edited file keeps the rest of
+its content and is backed up once to `<name>.context-graph.bak`.
+
+| Agent | Built-in memory, and the switch | Server registered in | Session-start text reaches the model through |
+|---|---|---|---|
+| Claude Code | auto memory; `autoMemoryEnabled: false` | the plugin | `SessionStart` `additionalContext` |
+| Codex | memories; three keys in `config.toml` | the plugin | `SessionStart` `additionalContext` (~2,500-token cap) |
+| Copilot CLI | Copilot Memory (on GitHub, not importable); `"memory": false` in `~/.copilot/settings.json` | `~/.copilot/mcp-config.json` (no allow-list: approve once, or `--allow-tool=context-graph`) | `sessionStart` top-level `additionalContext` |
+| Cursor | none (Memories was removed) | `~/.cursor/mcp.json`; allow `Mcp(context-graph:*)` in `~/.cursor/cli-config.json` | `sessionStart` `additional_context` (the IDE's agent window can drop it; untested here) |
+| OpenCode | none | `mcp.servers` in `~/.config/opencode/opencode.json`, `codemode: false`; an allow rule in `permissions` | the plugin's `context` hook, added to the system prompt of every request |
+| Antigravity CLI | none (Knowledge is off in the CLI) | `~/.gemini/config/mcp_config.json`; allow `mcp(context-graph/*)` in `~/.gemini/antigravity-cli/settings.json` | `SessionStart` `injectSteps` system message |
+| Grok Build | topic notes under `~/.grok/memory-v2/`, imported to `/memories/grok/`; `[memory_v2] enabled = false` | `~/.grok/config.toml`; allow `MCPTool(context-graph__*)` | the MCP server's `instructions` (`mcp --session-context`): Grok's start hooks can't reach the model |
+
+Antigravity's hooks carry no prompt or reply text, so its turns are read from
+the transcript its `Stop` payload points at; that is what gives its sessions a
+place in recall and in the next session's "where you left off".
+
+`live-hooks-e2e.sh memory` checks this against each installed agent: a memory
+written, one read back in a new session, and the next session's index and last
+ask.
+
 ### Codex and Claude Code Plugins
 
 Both runtimes have a distributable Runtime Plugin that wires hooks and the MCP server; marketplace

{memgraph_context_graph-0.7.4 → memgraph_context_graph-0.9.0}/docs/command-hooks.md

@@ -5,12 +5,13 @@ Protocol, then routes those events to graph connectors. The installed command
 is the same for every runtime:
 
 ```bash
-memgraph-context-graph hook run <runtime> \
-  --connector skills-graph \
-  --connector actions-graph \
-  --connector sessions-graph
+memgraph-context-graph hook run <runtime>
 ```
 
+It enables the graph connectors the config file's `[capture] connectors`
+names (unset: `skills-graph`, `actions-graph`, `sessions-graph`). Repeated
+`--connector` flags override that for one hook command.
+
 Runtime registrations are discovered through the
 `memgraph_context_graph.runtimes` Python entry-point group.
 
@@ -36,8 +37,9 @@ memgraph-context-graph hook init antigravity-cli
 memgraph-context-graph hook init grok
 ```
 
-`hook init` enables all three built-in connectors by default. Use repeated
-`--connector` flags to select a subset. Existing Copilot, Cursor, Antigravity, and Grok
+`hook init` writes hook commands without `--connector` flags, so they enable
+`[capture] connectors`. Repeated `--connector` flags pin a set into the
+generated commands instead. Existing Copilot, Cursor, Antigravity, and Grok
 JSON documents are merged without removing unrelated settings or hooks.
 OpenCode's generated plugin is replaced only with `--force`.
 
@@ -139,15 +141,15 @@ never deletes its session, so those sessions only ever see turn ends.
 Antigravity CLI (`agy`, the successor to Gemini CLI) reads named hook groups
 from `.agents/hooks.json`; `hook init` owns the `memgraph-context-graph` group and
 merges it beside any others. Only the tool events (`PreToolUse`,
-`PostToolUse`) take matcher groups. `PreInvocation` and `Stop` are written as
+`PostToolUse`) take matcher groups. `SessionStart` and `Stop` are written as
 flat handlers, because `agy` rejects the whole file when a lifecycle event is
 nested. Timeouts are in seconds.
 
 ```json
 {
   "memgraph-context-graph": {
-    "PreInvocation": [
-      {"type": "command", "command": "memgraph-context-graph hook run antigravity-cli --event-name PreInvocation", "timeout": 30}
+    "SessionStart": [
+      {"type": "command", "command": "memgraph-context-graph hook run antigravity-cli --event-name SessionStart", "timeout": 30}
     ],
     "PreToolUse": [
       {"hooks": [{"type": "command", "command": "memgraph-context-graph hook run antigravity-cli --event-name PreToolUse", "timeout": 30}]}
@@ -246,12 +248,11 @@ memgraph-context-graph setup antigravity-cli --project-dir "$PWD"
 Smoke-test a registration and its configured connectors:
 
 ```bash
-memgraph-context-graph doctor --runtime cursor \
-  --connector skills-graph \
-  --connector actions-graph \
-  --connector sessions-graph
+memgraph-context-graph doctor --runtime cursor
 ```
 
+`doctor` checks the `[capture] connectors` set unless `--connector` flags name others.
+
 Each runtime provides its own native probe payload; `doctor` does not assume
 that every runtime calls its session-end event `Stop`.
 

{memgraph_context_graph-0.7.4 → memgraph_context_graph-0.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "memgraph-context-graph"
-version = "0.7.4"
+version = "0.9.0"
 description = "Connect agent SDKs to context-graph components (actions-graph, skills-graph, etc.)"
 readme = "README.md"
 license = { text = "MIT" }

{memgraph_context_graph-0.7.4 → memgraph_context_graph-0.9.0}/src/memgraph_context_graph/adapters/_identity.py

@@ -85,6 +85,11 @@ class HookConfig:
     memgraph_database: str = _MEMGRAPH_DEFAULTS["database"]
     openai_api_key: str = _LLM_DEFAULTS["openai_api_key"]
     anthropic_api_key: str = _LLM_DEFAULTS["anthropic_api_key"]
+    #: ``[llm] derive_model``: the model ontology derivation calls; None means the provider's default.
+    derive_model: str | None = None
+    #: ``[capture] connectors``: the graph connectors a hook enables when its command names none;
+    #: None (never set) means memgraph_context_graph.connectors.DEFAULT_CONNECTORS.
+    connectors: tuple[str, ...] | None = None
     auto_reconcile: bool | None = None
     #: The model recall embeds with; None means the consumer's own default.
     embedding_model: str | None = None
@@ -95,12 +100,18 @@ class HookConfig:
     ontology_path: str | None = None
     #: ``[ontology] derive``: "extend" (the default) or "off"; see sessions-graph's ontology module.
     ontology_derive: str | None = None
+    #: ``[extraction]`` keys (GLiNER2 checkpoint, thresholds, chunking), as written: sessions-graph
+    #: validates them, this module only keeps them across rewrites.
+    extraction_settings: dict[str, str] = field(default_factory=dict)
     #: ``[github] token``: overrides the ``gh`` login resources-graph's Sweep otherwise fetches with.
     github_token: str | None = None
     #: ``[memory] backend``: ``"context-graph"`` when the user has handed their
     #: harness memory to the graph (the ``memory`` tool and session-start index
     #: are on); ``"native"`` or None leaves the harness's own memory in charge.
     memory_backend: str | None = None
+    #: ``[session_start] resume``: whether a session starts with a brief of the
+    #: previous sessions in its project. None (never set) means on.
+    session_resume: bool | None = None
     #: The ``section.key`` names the file actually sets (top-level keys as ``key``), so a check can tell
     #: "left at the default" from "written": Enterprise refuses an explicit ``identity.user_id`` or
     #: ``memgraph.database``, which would quietly override what the login decides.
@@ -183,7 +194,7 @@ def resolve_auto_reconcile() -> bool:
     """Resolve whether sessions-graph should auto-trigger reconciliation on SESSION_END.
 
     Config file only (ADR 0002); never configured means ``False``, matching
-    ``SessionsGraphConnector``'s default, since reconciliation costs LLM calls.
+    ``SessionsGraphConnector``'s default.
     """
     return bool(load_config().auto_reconcile)
 
@@ -193,6 +204,16 @@ def resolve_embedding_model() -> str | None:
     return load_config().embedding_model
 
 
+def resolve_extraction() -> dict[str, str]:
+    """The configured ``[extraction]`` keys, as written; sessions-graph owns their meaning."""
+    return dict(load_config().extraction_settings)
+
+
+def resolve_derive_model() -> str | None:
+    """The configured ``[llm] derive_model``, or None to leave the provider's default."""
+    return load_config().derive_model
+
+
 def resolve_ontology() -> tuple[str | None, str | None]:
     """The configured ``[ontology]`` (path, derive), each None when unset; sessions-graph owns their meaning."""
     config = load_config()
@@ -216,12 +237,15 @@ def write_config(
     memgraph_database: str | None = None,
     openai_api_key: str | None = None,
     anthropic_api_key: str | None = None,
+    derive_model: str | None = None,
+    connectors: tuple[str, ...] | None = None,
     auto_reconcile: bool | None = None,
     embedding_model: str | None = None,
     ontology_path: str | None = None,
     ontology_derive: str | None = None,
     github_token: str | None = None,
     memory_backend: str | None = None,
+    session_resume: bool | None = None,
 ) -> Path:
     """Write or update the config file. Returns the path written to.
 
@@ -237,12 +261,15 @@ def write_config(
         "memgraph_database": memgraph_database,
         "openai_api_key": openai_api_key,
         "anthropic_api_key": anthropic_api_key,
+        "derive_model": derive_model,
+        "connectors": connectors,
         "auto_reconcile": auto_reconcile,
         "embedding_model": embedding_model,
         "ontology_path": ontology_path,
         "ontology_derive": ontology_derive,
         "github_token": github_token,
         "memory_backend": memory_backend,
+        "session_resume": session_resume,
     }
     config = replace(_read_config_file(), **{key: value for key, value in updates.items() if value is not None})
     return _write_config_file(_render_config(config))
@@ -261,8 +288,8 @@ def write_full_config(
 ) -> Path:
     """Write a complete config file, resetting identity, Memgraph and LLM settings to what is given.
 
-    Every other section (``[reconcile]``, ``[recall]``, ``[ontology]``, ``[github]``, ``[memory]``) and the
-    edition are kept from the existing file, since only ``config set`` or a hand edit ever sets them.
+    Every other section (``[capture]``, ``[reconcile]``, ``[recall]``, ``[ontology]``, ``[extraction]``,
+    ``[github]``, ``[memory]``, ``[session_start]``), ``[llm] derive_model`` and the edition are kept from the existing file, since only ``config set`` or a hand edit ever sets them.
     ``auto_reconcile`` is kept likewise unless given here. :func:`write_config` is the partial update.
     """
     existing = _read_config_file()
@@ -308,11 +335,14 @@ def _read_config_file() -> HookConfig:
     identity = sections.get("identity", {})
     memgraph = sections.get("memgraph", {})
     llm = sections.get("llm", {})
+    capture = sections.get("capture", {})
     reconcile = sections.get("reconcile", {})
     recall = sections.get("recall", {})
     ontology = sections.get("ontology", {})
+    extraction = sections.get("extraction", {})
     github = sections.get("github", {})
     memory = sections.get("memory", {})
+    session_start = sections.get("session_start", {})
     auto_reconcile_raw = reconcile.get("auto_reconcile")
 
     return HookConfig(
@@ -324,13 +354,17 @@ def _read_config_file() -> HookConfig:
         memgraph_database=memgraph.get("database") or _MEMGRAPH_DEFAULTS["database"],
         openai_api_key=llm.get("openai_api_key", _LLM_DEFAULTS["openai_api_key"]),
         anthropic_api_key=llm.get("anthropic_api_key", _LLM_DEFAULTS["anthropic_api_key"]),
+        derive_model=llm.get("derive_model") or None,
+        connectors=_parse_list(capture["connectors"]) if "connectors" in capture else None,
         auto_reconcile=parse_bool_flag(auto_reconcile_raw) if auto_reconcile_raw is not None else None,
         embedding_model=recall.get("embedding_model") or None,
         recall_settings={key: value for key, value in recall.items() if key != "embedding_model"},
         ontology_path=ontology.get("path") or None,
         ontology_derive=ontology.get("derive") or None,
+        extraction_settings=dict(extraction),
         github_token=github.get("token") or None,
         memory_backend=memory.get("backend") or None,
+        session_resume=parse_bool_flag(session_start["resume"]) if session_start.get("resume") else None,
         present=frozenset(
             f"{section}.{key}" if section else key
             for section, keys in sections.items()
@@ -341,6 +375,11 @@ def _read_config_file() -> HookConfig:
     )
 
 
+def _parse_list(value: str) -> tuple[str, ...]:
+    """A comma-separated value (``"a, b"``) as its non-blank items; the parser has no arrays."""
+    return tuple(item.strip() for item in value.split(",") if item.strip())
+
+
 def _parse_toml(path: Path, problems: list[str] | None = None) -> dict[str, dict[str, str]]:
     """Minimal TOML parser — handles [section] and key = "value" pairs.
 
@@ -379,8 +418,9 @@ def _render_config(config: HookConfig) -> str:
     """Render the full config file content.
 
     ``[reconcile]`` is omitted while ``auto_reconcile`` is ``None`` so a re-read keeps "never configured"
-    distinct from an explicit ``false``; ``[recall]``, ``[ontology]``, ``[github]`` and ``[memory]`` are
-    omitted while they hold nothing.
+    distinct from an explicit ``false``, and ``[session_start]`` likewise while ``session_resume`` is;
+    ``[capture]`` likewise while ``connectors`` is; ``[recall]``, ``[ontology]``, ``[extraction]``, ``[github]``
+    and ``[memory]`` are omitted while they hold nothing.
     """
     user_id = config.user_id or ""
     lines = [
@@ -400,7 +440,10 @@ def _render_config(config: HookConfig) -> str:
         "[llm]",
         f'openai_api_key = "{config.openai_api_key}"',
         f'anthropic_api_key = "{config.anthropic_api_key}"',
+        *([f'derive_model = "{config.derive_model}"'] if config.derive_model else []),
     ]
+    if config.connectors is not None:
+        lines += ["", "[capture]", f'connectors = "{", ".join(config.connectors)}"']
     if config.auto_reconcile is not None:
         lines += ["", "[reconcile]", f"auto_reconcile = {'true' if config.auto_reconcile else 'false'}"]
     recall = (
@@ -415,10 +458,14 @@ def _render_config(config: HookConfig) -> str:
     }
     if ontology:
         lines += ["", "[ontology]", *(f'{key} = "{value}"' for key, value in ontology.items())]
+    if config.extraction_settings:
+        lines += ["", "[extraction]", *(f'{key} = "{value}"' for key, value in config.extraction_settings.items())]
     if config.github_token:
         lines += ["", "[github]", f'token = "{config.github_token}"']
     if config.memory_backend:
         lines += ["", "[memory]", f'backend = "{config.memory_backend}"']
+    if config.session_resume is not None:
+        lines += ["", "[session_start]", f"resume = {'true' if config.session_resume else 'false'}"]
     lines.append("")
     return "\n".join(lines)
 

{memgraph_context_graph-0.7.4 → memgraph_context_graph-0.9.0}/src/memgraph_context_graph/adapters/_opencode_plugin.js

@@ -25,6 +25,24 @@ function capture(payload) {
   })
 }
 
+// The hook's stdout, parsed: what the hook wants added to the session, or null.
+function ask(payload) {
+  return new Promise((resolve) => {
+    const child = spawn(command[0], command.slice(1), { stdio: ["pipe", "pipe", "inherit"] })
+    let out = ""
+    child.stdout.on("data", (chunk) => (out += chunk))
+    child.on("error", () => resolve(null))
+    child.on("close", () => {
+      try {
+        resolve(out.trim() ? JSON.parse(out) : null)
+      } catch {
+        resolve(null)
+      }
+    })
+    child.stdin.end(JSON.stringify(payload))
+  })
+}
+
 export default {
   id: "memgraph.memgraph-context-graph",
   async setup(ctx) {
@@ -43,6 +61,24 @@ export default {
       return capture({ hook_event_name: "session.created", session_id: sessionID, cwd, model })
     }
 
+    // The session-start text (memory index, where the user left off), asked for once per session. The context
+    // hook runs before every model request and rebuilds the system prompt each time, so it is re-added from
+    // this cache on each one; compaction and title generation build their own requests and get it too.
+    const sessionContext = new Map()
+    const addSessionContext = async (event) => {
+      if (!sessionContext.has(event.sessionID)) {
+        sessionContext.set(
+          event.sessionID,
+          ask({ hook_event_name: "session.context", session_id: event.sessionID, cwd: ctx.location?.directory }),
+        )
+      }
+      const response = await sessionContext.get(event.sessionID)
+      if (typeof response?.system === "string" && response.system) event.system.push({ type: "text", text: response.system })
+    }
+    for (const name of ["context", "compaction", "generate"]) {
+      registrations.push(await ctx.session.hook(name, addSessionContext))
+    }
+
     registrations.push(await ctx.session.hook("prompt", async (event) => {
       openTurns.add(event.sessionID)
       await start(event.sessionID, ctx.location?.directory)