@gamaze/hicortex 0.12.1 → 0.13.1

package/dist/lessons-context.js

@@ -23,9 +23,14 @@
  * CC session, and a broken /context fetch must never blank the whole output.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.titleCaseSection = titleCaseSection;
+exports.orderSectionNames = orderSectionNames;
+exports.renderContextBlock = renderContextBlock;
+exports.gateAndRenderContext = gateAndRenderContext;
 exports.fetchLessonsContext = fetchLessonsContext;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
+const context_store_js_1 = require("./context-store.js");
 const features_js_1 = require("./features.js");
 const extensions_js_1 = require("./extensions.js");
 const state_js_1 = require("./state.js");
@@ -50,7 +55,13 @@ function resolveConfig() {
     const serverUrl = config.mode === "client" && typeof config.serverUrl === "string"
         ? config.serverUrl.replace(/\/+$/, "")
         : `http://127.0.0.1:${config.port ?? DEFAULT_PORT}`;
-    return { serverUrl, authToken: config.authToken, home };
+    // Per-agent context id (0.13) via the shared resolver, so the id sent here
+    // always matches what `hicortex status` reports. No configured agentName →
+    // agentId null → NO ?agent= (bare fetch): CC's default is the shared global
+    // context. A configured agentName that sanitizes to null → agentId null too
+    // (NO ?agent=), never a 400 that the fail-soft hook would silently swallow.
+    const agentName = (0, context_store_js_1.resolveAgentIdentity)(config).agentId;
+    return { serverUrl, authToken: config.authToken, home, agentName };
 }
 function authHeaders(authToken) {
     return authToken ? { "Authorization": `Bearer ${authToken}` } : {};
@@ -112,6 +123,8 @@ async function fetchLessonsBlock(cfg) {
 /**
  * Title-case a section name for its heading: split on `-`/`_`, capitalize each
  * word ("user" → "User", "my_notes" → "My Notes").
+ * Exported so the OC plugin (index.ts) renders the `## Context` block
+ * identically to the CC hook rather than duplicating the logic.
  */
 function titleCaseSection(name) {
     return name
@@ -124,7 +137,7 @@ function titleCaseSection(name) {
  * Stable section ordering: `user` first, then `rules` (the seeded primary
  * sections, spec §8), then every other section alphabetically. Server-side
  * enumeration order (readdirSync) is FS-dependent, so we sort here for a
- * deterministic injection block.
+ * deterministic injection block. Exported for reuse by the OC plugin.
  */
 function orderSectionNames(names) {
     const primaries = ["user", "rules"].filter((p) => names.includes(p));
@@ -132,23 +145,13 @@ function orderSectionNames(names) {
     return [...primaries, ...rest];
 }
 /**
- * Fetch /context and build the `## Context` block, or null when nothing should
- * be injected: non-2xx, this harness not in `clients`, no sections, or all
- * sections empty. Throws propagate to the caller's fail-soft catch.
+ * Render the `## Context` block from a resolved section map, or null when there
+ * is nothing to inject (no sections, or every section blank after trimming).
+ * Pure — no gating, no I/O. Shared verbatim by the CC hook and the OC plugin so
+ * both harnesses emit an identical block. Sections are ordered (user, rules,
+ * then alphabetical) and rendered under title-cased `###` headings.
  */
-async function fetchContextBlock(cfg) {
-    const resp = await fetch(`${cfg.serverUrl}/context`, {
-        headers: authHeaders(cfg.authToken),
-        signal: AbortSignal.timeout(3000),
-    });
-    if (!resp.ok)
-        return null;
-    const data = await resp.json();
-    // Self-gate: only inject when this harness is in the server-resolved list.
-    const clients = Array.isArray(data.clients) ? data.clients : [];
-    if (!clients.includes(THIS_HARNESS))
-        return null;
-    const sections = data.sections;
+function renderContextBlock(sections) {
     if (!sections || typeof sections !== "object" || Array.isArray(sections))
         return null;
     const names = orderSectionNames(Object.keys(sections));
@@ -163,6 +166,62 @@ async function fetchContextBlock(cfg) {
         return null;
     return ["## Context", "", ...bodyParts].join("\n");
 }
+/**
+ * Gate a GET /context response and render the `## Context` block, or null when
+ * nothing should be injected: `harness` not in the server-resolved `clients`,
+ * an empty/blank section set, or — when `requireAgentEcho` — a response that
+ * does not echo `agent`. The SINGLE gate used by both CC and OC so the two can
+ * never drift (the Python Hermes plugin `provider.py::_context_block` mirrors
+ * this logic — keep them in sync).
+ *
+ * `requireAgentEcho` is the old-server guard, and it is the CALLER's decision:
+ *   - OC passes `agentId !== null` — when it actually sent an id, a 0.12 server
+ *     that ignores `?agent=` (200 global, no echo) must NOT leak global context
+ *     into every persona; on a bare fetch (no id) the guard is off (amendment
+ *     A2).
+ *   - CC passes `false` ALWAYS and deliberately (see the call site): a thin CC
+ *     client auto-upgrades via npx BEFORE bedrock does, so during the upgrade
+ *     window it talks to a 0.12 server that cannot hold ANY per-agent config —
+ *     global IS the operator's intended state there, and a guard would instead
+ *     blank ALL context for every CC session in that window.
+ */
+function gateAndRenderContext(data, harness, opts) {
+    if (!data || typeof data !== "object")
+        return null;
+    const clients = Array.isArray(data.clients) ? data.clients : [];
+    if (!clients.includes(harness))
+        return null;
+    if (opts.requireAgentEcho && typeof data.agent !== "string")
+        return null;
+    return renderContextBlock(data.sections ?? {});
+}
+/**
+ * Fetch /context and build the `## Context` block, or null when nothing should
+ * be injected: non-2xx, this harness not in `clients`, no sections, or all
+ * sections empty. Throws propagate to the caller's fail-soft catch.
+ */
+async function fetchContextBlock(cfg) {
+    // Send ?agent= only when we have a valid id; the server does the merge and
+    // returns the resolved sections, so the hook stays dumb (no client-side mode
+    // logic). A null id (CC's default: no configured agentName, or a configured
+    // value that sanitizes to nothing) → bare /context → the shared global set.
+    const url = cfg.agentName
+        ? `${cfg.serverUrl}/context?agent=${encodeURIComponent(cfg.agentName)}`
+        : `${cfg.serverUrl}/context`;
+    const resp = await fetch(url, {
+        headers: authHeaders(cfg.authToken),
+        signal: AbortSignal.timeout(3000),
+    });
+    if (!resp.ok)
+        return null;
+    const data = await resp.json();
+    // CC deliberately passes requireAgentEcho: false (NOT the OC/Hermes old-server
+    // guard). A thin CC client auto-upgrades via npx BEFORE bedrock does, so
+    // mid-upgrade it may hit a 0.12 server that returns global context with no
+    // `agent` echo — and a 0.12 server cannot hold per-agent config, so global is
+    // the intended state. Guarding here would blank ALL CC context in that window.
+    return gateAndRenderContext(data, THIS_HARNESS, { requireAgentEcho: false });
+}
 /**
  * Fetch context + lessons concurrently and return the combined Markdown block,
  * or null when neither yields anything (nothing to inject; caller prints

package/dist/llm.d.ts

@@ -68,6 +68,25 @@ export declare function resolveExplicitLlmConfig(overrides?: {
  * the transition for any lingering call sites — remove after 0.10.0 ships.
  */
 export declare const resolveLlmConfigForCC: typeof resolveExplicitLlmConfig;
+export type { ModelTierOverride } from "./types.js";
+/**
+ * Normalize a nested `models: { <tier>: {model,baseUrl,apiKey,provider} }` block
+ * onto the flat `llm*` / `distill*` / `reflect*` / `classify*` keys the resolver
+ * already consumes. Nested overrides WIN over any flat key of the same name; every
+ * non-mapped key (llmBackend, licenseKey, distillFallback, contextClients, …)
+ * is preserved via spread. Pure: returns the SAME reference when there is no
+ * `models` key, so this is a provable no-op for every existing install.
+ *
+ * Robust to a malformed config.json: a config that parses to a scalar, array,
+ * or null is returned untouched (matching the pre-0.13.1 optional-chaining
+ * tolerance — this function must never throw at server/nightly boot).
+ *
+ * Fail-explicit (warn + skip, never throw): an invalid `models` value, an
+ * unknown tier name, a non-object tier value, a non-string field value, a tier
+ * apiKey/provider set without a baseUrl (they are baseUrl-gated downstream), and
+ * a dead score apiKey/provider under an ollama base.
+ */
+export declare function applyModelsBlock(saved: Record<string, unknown> | null): Record<string, unknown> | null;
 /**
  * Resolve an LlmConfig from a saved ~/.hicortex/config.json object.
  *
@@ -79,8 +98,12 @@ export declare const resolveLlmConfigForCC: typeof resolveExplicitLlmConfig;
  *
  * Returns `reason: "claude_binary_missing"` when claude-cli is configured but
  * the binary can't be found, so callers can log a context-specific message.
+ *
+ * `findBinary` is injectable (defaults to the real `findClaudeBinary`) so the
+ * claude-cli branch — including the missing-binary passthrough — can be pinned
+ * deterministically in tests without depending on the host filesystem.
  */
-export declare function resolveSavedLlmConfig(savedConfig: Record<string, unknown> | null): {
+export declare function resolveSavedLlmConfig(savedConfig: Record<string, unknown> | null, findBinary?: () => string | null): {
     config: LlmConfig | null;
     reason?: "claude_binary_missing";
 };

package/dist/llm.js

@@ -17,6 +17,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LlmClient = exports.RateLimitError = exports.resolveLlmConfigForCC = void 0;
 exports.resolveExplicitLlmConfig = resolveExplicitLlmConfig;
+exports.applyModelsBlock = applyModelsBlock;
 exports.resolveSavedLlmConfig = resolveSavedLlmConfig;
 exports.resolveClassifyProbeTarget = resolveClassifyProbeTarget;
 exports.findClaudeBinary = findClaudeBinary;
@@ -70,6 +71,117 @@ function resolveExplicitLlmConfig(overrides) {
  * the transition for any lingering call sites — remove after 0.10.0 ships.
  */
 exports.resolveLlmConfigForCC = resolveExplicitLlmConfig;
+/**
+ * Map from a `models.<tier>` name to the flat config keys it feeds. The base
+ * tier is `score` — score IS the base model today (completeFast reads
+ * config.model), so it lands on the llm* keys and its `provider` is ignored
+ * (the base provider comes from llmBackend / detectProvider, not config).
+ * Tiers with a `provider` key (distill/reflect/classify) apply their apiKey +
+ * provider through a baseUrl-gated overlay downstream; `score` (no provider
+ * key) rides the base resolution.
+ */
+const MODELS_TIER_KEYS = {
+    score: { model: "llmModel", baseUrl: "llmBaseUrl", apiKey: "llmApiKey" },
+    distill: { model: "distillModel", baseUrl: "distillBaseUrl", apiKey: "distillApiKey", provider: "distillProvider" },
+    reflect: { model: "reflectModel", baseUrl: "reflectBaseUrl", apiKey: "reflectApiKey", provider: "reflectProvider" },
+    classify: { model: "classifyModel", baseUrl: "classifyBaseUrl", apiKey: "classifyApiKey", provider: "classifyProvider" },
+};
+/**
+ * Normalize a nested `models: { <tier>: {model,baseUrl,apiKey,provider} }` block
+ * onto the flat `llm*` / `distill*` / `reflect*` / `classify*` keys the resolver
+ * already consumes. Nested overrides WIN over any flat key of the same name; every
+ * non-mapped key (llmBackend, licenseKey, distillFallback, contextClients, …)
+ * is preserved via spread. Pure: returns the SAME reference when there is no
+ * `models` key, so this is a provable no-op for every existing install.
+ *
+ * Robust to a malformed config.json: a config that parses to a scalar, array,
+ * or null is returned untouched (matching the pre-0.13.1 optional-chaining
+ * tolerance — this function must never throw at server/nightly boot).
+ *
+ * Fail-explicit (warn + skip, never throw): an invalid `models` value, an
+ * unknown tier name, a non-object tier value, a non-string field value, a tier
+ * apiKey/provider set without a baseUrl (they are baseUrl-gated downstream), and
+ * a dead score apiKey/provider under an ollama base.
+ */
+function applyModelsBlock(saved) {
+    // Guard the container itself first — `"models" in saved` throws a TypeError on
+    // a truthy non-object (config.json = `true`/`5`/`"x"`); such configs must pass
+    // through so the boot path degrades to recall-only exactly as before.
+    if (typeof saved !== "object" || saved === null || Array.isArray(saved))
+        return saved;
+    if (!("models" in saved))
+        return saved;
+    const models = saved.models;
+    if (typeof models !== "object" || models === null || Array.isArray(models)) {
+        console.warn(`[hicortex] Ignoring invalid "models" config: expected an object of per-tier overrides, got ${Array.isArray(models) ? "array" : models === null ? "null" : typeof models}`);
+        return saved;
+    }
+    const ollamaBase = saved.llmBackend === "ollama";
+    const mapped = {};
+    for (const [tier, value] of Object.entries(models)) {
+        const keys = MODELS_TIER_KEYS[tier];
+        if (!keys) {
+            console.warn(`[hicortex] Ignoring unknown "models" tier "${tier}" (expected: score, distill, reflect, classify)`);
+            continue;
+        }
+        if (typeof value !== "object" || value === null || Array.isArray(value)) {
+            console.warn(`[hicortex] Ignoring invalid "models.${tier}" override: expected an object with model/baseUrl/apiKey/provider`);
+            continue;
+        }
+        const o = value;
+        // Per-field string validation: a non-string value would map verbatim and
+        // fail opaquely downstream (e.g. baseUrl: 11434), so drop it with a warning.
+        const strField = (name) => {
+            const v = o[name];
+            if (v === undefined)
+                return undefined;
+            if (typeof v !== "string") {
+                console.warn(`[hicortex] Ignoring non-string "models.${tier}.${name}" (expected a string)`);
+                return undefined;
+            }
+            return v;
+        };
+        const model = strField("model");
+        const baseUrl = strField("baseUrl");
+        const apiKey = strField("apiKey");
+        const provider = strField("provider");
+        if (model !== undefined)
+            mapped[keys.model] = model;
+        if (baseUrl !== undefined)
+            mapped[keys.baseUrl] = baseUrl;
+        if (keys.provider) {
+            // Overlay tier (distill/reflect/classify): the downstream overlay only
+            // consumes apiKey/provider when the tier ALSO sets its own baseUrl.
+            // Without one, they would silently bill to the base key — so warn + drop.
+            if ((apiKey !== undefined || provider !== undefined) && baseUrl === undefined) {
+                console.warn(`[hicortex] Ignoring "models.${tier}" apiKey/provider without a baseUrl: they only take effect when the tier sets its own baseUrl`);
+            }
+            else {
+                if (apiKey !== undefined)
+                    mapped[keys.apiKey] = apiKey;
+                if (provider !== undefined)
+                    mapped[keys.provider] = provider;
+            }
+        }
+        else {
+            // score = base tier: no separate provider key, and apiKey rides llmApiKey.
+            if (provider !== undefined) {
+                console.warn(`[hicortex] Ignoring "models.score.provider": the base provider comes from llmBackend (or is auto-detected from the endpoint)`);
+            }
+            if (apiKey !== undefined) {
+                if (ollamaBase) {
+                    // The ollama base path hardcodes an empty api key and never reads
+                    // llmApiKey, so score.apiKey is dead there.
+                    console.warn(`[hicortex] Ignoring "models.score.apiKey": the base ollama path sends no api key`);
+                }
+                else {
+                    mapped[keys.apiKey] = apiKey;
+                }
+            }
+        }
+    }
+    return { ...saved, ...mapped };
+}
 /**
  * Resolve an LlmConfig from a saved ~/.hicortex/config.json object.
  *
@@ -81,11 +193,16 @@ exports.resolveLlmConfigForCC = resolveExplicitLlmConfig;
  *
  * Returns `reason: "claude_binary_missing"` when claude-cli is configured but
  * the binary can't be found, so callers can log a context-specific message.
+ *
+ * `findBinary` is injectable (defaults to the real `findClaudeBinary`) so the
+ * claude-cli branch — including the missing-binary passthrough — can be pinned
+ * deterministically in tests without depending on the host filesystem.
  */
-function resolveSavedLlmConfig(savedConfig) {
+function resolveSavedLlmConfig(savedConfig, findBinary = findClaudeBinary) {
+    savedConfig = applyModelsBlock(savedConfig);
     let llmConfig = null;
     if (savedConfig?.llmBackend === "claude-cli") {
-        const claudePath = findClaudeBinary();
+        const claudePath = findBinary();
         if (claudePath) {
             llmConfig = claudeCliConfig(claudePath);
         }

package/dist/mcp-server.js

@@ -81,6 +81,10 @@ let stateDir = "";
 // Resolved contextClients list (spec §2) — the harness names allowed to inject
 // the standing context layer. Echoed by GET /context so each hook self-gates.
 let contextClients = ["cc"];
+// Resolved contextAgents map (0.13) — agent id → mode (override/global/off).
+// Read once at boot (like contextClients); the drop-in-a-dir presence path is
+// per-request, so only explicit config entries need a daemon restart to apply.
+let contextAgents = {};
 // Cache detectChunkSize results keyed by "<provider>/<model>@<baseUrl>" so we
 // probe each endpoint once per server boot rather than once per /distill request.
 const chunkSizeCache = new Map();
@@ -328,7 +332,7 @@ async function startServer(options = {}) {
     // Named backends (claude-cli, ollama) → immediate config; everything else
     // goes through resolveExplicitLlmConfig which requires a user-chosen provider.
     // If nothing is configured: start recall-only with an unmissable warning.
-    const savedConfig = readConfigFile(stateDir);
+    const savedConfig = (0, llm_js_1.applyModelsBlock)(readConfigFile(stateDir));
     if (savedConfig?.llmBackend === "claude-cli") {
         const claudePath = (0, llm_js_1.findClaudeBinary)();
         if (claudePath) {
@@ -436,6 +440,16 @@ async function startServer(options = {}) {
         console.warn(`[hicortex] Ignoring unknown contextClients: ${resolvedClients.dropped.join(", ")} ` +
             `(known: cc, hermes, oc)`);
     }
+    // Per-agent context (0.13): resolve the config-declared modes. Warn once per
+    // boot on dropped entries (bad key or bad mode) so typos surface. NOTE: this
+    // map is boot-time; editing contextAgents needs a daemon restart. Dropping an
+    // agents/<id> dir onto disk takes effect immediately (per-request presence).
+    const resolvedAgents = (0, context_store_js_1.resolveContextAgents)(savedConfig?.contextAgents);
+    contextAgents = resolvedAgents.agents;
+    if (resolvedAgents.dropped.length > 0) {
+        console.warn(`[hicortex] Ignoring invalid contextAgents entries: ${resolvedAgents.dropped.join(", ")} ` +
+            `(keys must match ^[a-z0-9][a-z0-9_-]*$; modes must be override|global|off)`);
+    }
     // Express app
     const app = (0, express_1.default)();
     // Raise the body limit — whole-session denoised transcripts exceed the 100 kB default.
@@ -620,7 +634,7 @@ async function startServer(options = {}) {
     // which the tests exercise directly — no mirror-app drift.
     app.get("/context", (req, res) => {
         try {
-            const r = (0, context_store_js_1.handleContextGet)((0, node_path_1.join)(stateDir, "context"), contextClients, req.query);
+            const r = (0, context_store_js_1.handleContextGet)((0, node_path_1.join)(stateDir, "context"), contextClients, req.query, contextAgents);
             res.status(r.status).json(r.body);
         }
         catch (err) {
@@ -629,7 +643,7 @@ async function startServer(options = {}) {
     });
     app.put("/context", (req, res) => {
         try {
-            const r = (0, context_store_js_1.handleContextPut)((0, node_path_1.join)(stateDir, "context"), req.body);
+            const r = (0, context_store_js_1.handleContextPut)((0, node_path_1.join)(stateDir, "context"), req.body, req.query, contextAgents);
             if (r.warn)
                 console.warn(`[hicortex] ${r.warn}`);
             res.status(r.status).json(r.body);
@@ -703,7 +717,11 @@ async function startServer(options = {}) {
             ? `${session_id}${segment_id ? `#${segment_id}` : ""}`
             : undefined;
         try {
-            const entries = await (0, distiller_js_1.distillSession)(llm, conversationText, project ?? "unknown", date, chunkSize);
+            // Collect gate-dropped entries so they can ride back in the response and
+            // land in the caller's file-persisted nightly log (#156 audit trail); the
+            // server-side per-entry console.log in distillChunk stays as well.
+            const dropped = [];
+            const entries = await (0, distiller_js_1.distillSession)(llm, conversationText, project ?? "unknown", date, chunkSize, dropped);
             const ids = [];
             for (let i = 0; i < entries.length; i++) {
                 const entry = entries[i];
@@ -722,7 +740,11 @@ async function startServer(options = {}) {
                 });
                 ids.push(id);
             }
-            res.status(201).json({ ids, distilled: ids.length });
+            res.status(201).json({
+                ids,
+                distilled: ids.length,
+                dropped: dropped.map((d) => (d.length > 120 ? `${d.slice(0, 120)}…` : d)),
+            });
         }
         catch (err) {
             res.status(500).json({ error: "Distillation failed", message: err instanceof Error ? err.message : String(err) });

package/dist/nightly-status.js

@@ -18,6 +18,7 @@ const node_os_1 = require("node:os");
 const node_child_process_1 = require("node:child_process");
 const db_js_1 = require("./db.js");
 const state_js_1 = require("./state.js");
+const llm_js_1 = require("./llm.js");
 const HICORTEX_HOME = (0, paths_js_1.hicortexHome)();
 const CONFIG_PATH = (0, node_path_1.join)(HICORTEX_HOME, "config.json");
 async function showNightlyStatus() {
@@ -36,7 +37,9 @@ async function showNightlyStatus() {
     }
     // LLM config
     try {
-        const config = JSON.parse((0, node_fs_1.readFileSync)(CONFIG_PATH, "utf-8"));
+        // No `?? {}` coercion: a null/invalid parse must fall through to the catch
+        // below (as it did pre-0.13.1) rather than print a fabricated-healthy status.
+        const config = (0, llm_js_1.applyModelsBlock)(JSON.parse((0, node_fs_1.readFileSync)(CONFIG_PATH, "utf-8")));
         const backend = config.llmBackend ?? "auto-detect";
         const model = config.llmModel ?? "default";
         const mode = config.mode === "client" ? "client → " + (config.serverUrl ?? "?") : "server (local)";

package/dist/nightly.js

@@ -228,6 +228,10 @@ async function runNightly(options = {}) {
                     const data = await resp.json();
                     memoriesIngested += data.distilled ?? 0;
                     console.log(`[hicortex]     → ${data.distilled ?? 0} memories extracted`);
+                    // Durable audit trail (#156): the server truncates each dropped entry.
+                    for (const d of data.dropped ?? []) {
+                        console.log(`[hicortex]     Substance gate: dropped "${d}"`);
+                    }
                 }
                 else if (resp.status === 429) {
                     const data = await resp.json();
@@ -444,6 +448,10 @@ async function runClientNightly(config, dryRun) {
                 memoriesIngested += count;
                 sessionsSent++;
                 console.log(`[hicortex]     → ${count} memories sent to server`);
+                // Durable audit trail (#156): the server truncates each dropped entry.
+                for (const d of data.dropped ?? []) {
+                    console.log(`[hicortex]     Substance gate: dropped "${d}"`);
+                }
             }
             else if (resp.status === 401) {
                 console.error(`[hicortex]     Auth failed. Check authToken in ~/.hicortex/config.json`);

package/dist/status.d.ts

@@ -1,4 +1,13 @@
 /**
  * Hicortex status — show current configuration and stats.
  */
+/**
+ * The value shown after "Agent name:" in `hicortex status` (#179, A3). Reports
+ * EXACTLY what the CC hook resolves (shared `resolveAgentIdentity`), so the
+ * operator never keys `contextAgents`/`agents/<id>/` on an id the install does
+ * not actually send. Unset → the install sends no `?agent=` and shares the
+ * global context (CC default). A configured-but-unsanitizable value is called
+ * out as invalid (the hook sends none) rather than silently accepted.
+ */
+export declare function statusAgentLine(config: Record<string, unknown>): string;
 export declare function runStatus(): Promise<void>;

package/dist/status.js

@@ -3,6 +3,7 @@
  * Hicortex status — show current configuration and stats.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.statusAgentLine = statusAgentLine;
 exports.runStatus = runStatus;
 const paths_js_1 = require("./paths.js");
 const node_fs_1 = require("node:fs");
@@ -12,9 +13,29 @@ const node_child_process_1 = require("node:child_process");
 const db_js_1 = require("./db.js");
 const features_js_1 = require("./features.js");
 const state_js_1 = require("./state.js");
+const context_store_js_1 = require("./context-store.js");
 const HICORTEX_HOME = (0, paths_js_1.hicortexHome)();
 const CC_SETTINGS = (0, node_path_1.join)((0, node_os_1.homedir)(), ".claude", "settings.json");
 const OC_CONFIG = (0, node_path_1.join)((0, node_os_1.homedir)(), ".openclaw", "openclaw.json");
+/**
+ * The value shown after "Agent name:" in `hicortex status` (#179, A3). Reports
+ * EXACTLY what the CC hook resolves (shared `resolveAgentIdentity`), so the
+ * operator never keys `contextAgents`/`agents/<id>/` on an id the install does
+ * not actually send. Unset → the install sends no `?agent=` and shares the
+ * global context (CC default). A configured-but-unsanitizable value is called
+ * out as invalid (the hook sends none) rather than silently accepted.
+ */
+function statusAgentLine(config) {
+    const id = (0, context_store_js_1.resolveAgentIdentity)(config);
+    switch (id.source) {
+        case "configured":
+            return id.agentId;
+        case "invalid-config":
+            return `(invalid configured value "${id.rawConfigured}" — fix config.agentName; hook sends none)`;
+        default: // unset
+            return "(not set — global context)";
+    }
+}
 async function runStatus() {
     console.log("Hicortex Status");
     console.log("─".repeat(40));
@@ -42,11 +63,12 @@ async function runStatus() {
     let licenseKey = "";
     let savedAuthToken = "";
     let isClientMode = false;
+    let parsedConfig = {};
     try {
-        const config = JSON.parse((0, node_fs_1.readFileSync)(configPath, "utf-8"));
-        licenseKey = config.licenseKey ?? "";
-        savedAuthToken = config.authToken ?? "";
-        isClientMode = config.mode === "client";
+        parsedConfig = JSON.parse((0, node_fs_1.readFileSync)(configPath, "utf-8"));
+        licenseKey = parsedConfig.licenseKey ?? "";
+        savedAuthToken = parsedConfig.authToken ?? "";
+        isClientMode = parsedConfig.mode === "client";
     }
     catch { /* no config */ }
     const validated = (0, features_js_1.getValidatedLicense)();
@@ -65,6 +87,9 @@ async function runStatus() {
     else if (!isClientMode && !savedAuthToken) {
         console.log(`Auth token:   not configured (run: npx @gamaze/hicortex init)`);
     }
+    // Per-agent context id (#179) — the id this install sends as ?agent= and the
+    // key operators use for contextAgents / agents/<id>/ dirs.
+    console.log(`Agent name:   ${statusAgentLine(parsedConfig)}`);
     console.log();
     // Adapters
     console.log("Adapters:");

package/dist/types.d.ts

@@ -115,6 +115,16 @@ export interface ConsolidationReport {
         calls_by_stage: Record<string, number>;
     };
 }
+/**
+ * A single per-stage override inside the nested `models` server-config block.
+ * Consumed by `applyModelsBlock` (llm.ts), which re-exports this type.
+ */
+export interface ModelTierOverride {
+    model?: string;
+    baseUrl?: string;
+    apiKey?: string;
+    provider?: string;
+}
 /** Plugin configuration from openclaw.plugin.json configSchema. */
 export interface HicortexConfig {
     licenseKey?: string;
@@ -145,6 +155,16 @@ export interface HicortexConfig {
     classifyApiKey?: string;
     /** Optional provider for the classify endpoint (defaults to the base provider). */
     classifyProvider?: string;
+    /**
+     * Server config (NOT an OC-plugin key): nested per-stage model overrides.
+     * `{ score|distill|reflect|classify: { model?, baseUrl?, apiKey?, provider? } }`.
+     * Normalized onto the flat `llm*` / `distill*` / `reflect*` / `classify*`
+     * keys at read time (see applyModelsBlock in llm.ts); nested wins, and the
+     * flat keys remain supported at lower precedence. Happy path is a single model via
+     * `llmModel`; use this block only for per-stage routing. `score.provider` is
+     * ignored (base provider comes from llmBackend).
+     */
+    models?: Record<string, ModelTierOverride>;
     /** @deprecated Consolidation is owned by the server nightly. */
     consolidateHour?: number;
     /** @deprecated The OC plugin no longer opens its own database. */

package/hermes-plugin/hicortex/README.md

@@ -14,11 +14,24 @@ Gives [Hermes](https://github.com/nousresearch/hermes-agent) agents self-learnin
 |---|---|---|
 | `prefetch(query)` | recall relevant memories before each turn | `GET /search` |
 | `queue_prefetch(query)` | background recall for the next turn | `GET /search` |
-| `system_prompt_block()` | inject distilled lessons + memory index | `GET /lessons` |
+| `system_prompt_block()` | inject per-agent standing context + distilled lessons + memory index | `GET /context`, `GET /lessons` |
 | `get_tool_schemas()` | exposes the 8 unified tools | see tool table below |
 
 That's the whole surface. No `sync_turn`, no compaction/session-end capture — those are intentionally absent.
 
+### Per-agent standing context (0.13)
+
+`system_prompt_block()` also injects the hand-edited **standing context layer** (`## Context`, above the lessons block) — "who you are + how to work", distinct from episodic memory. The server resolves it **per agent**: this profile's own sections override the global set (`override`), or it can be `global` or `off`. See the main repo's `/context` layer docs.
+
+The plugin sends its **profile name** as `?agent=`, resolved in this order:
+
+1. `agent_name` in the plugin config (explicit override);
+2. the `HERMES_PROFILE` environment variable;
+3. a `HERMES_HOME` ending in `profiles/<name>` (the per-profile install path);
+4. none → the global context (backward compatible).
+
+Leave `agent_name` blank to auto-derive (2–4). Context injection needs a Hicortex server **≥ 0.13**; against an older server the plugin detects the missing per-agent support and injects no context (lessons are unaffected). Context and lessons fail soft independently — a context failure never costs the lessons block.
+
 ### Tools (unified 8)
 
 | Tool | REST call | Description |
@@ -57,7 +70,7 @@ hermes memory setup   # select "hicortex", enter the server URL/token when promp
 
 Run it once per profile if you use Hermes profiles. Hermes allows **one** external memory provider at a time, so disable Honcho (or any other) first, then restart the gateway.
 
-Config fields (`hicortex_url`, `default_project`, `recall_limit`, `privacy_filter`) can also be written to `$HERMES_HOME/plugins/hicortex/config.json` directly. The auth token is a **secret** — set it via env, not the JSON file:
+Config fields (`hicortex_url`, `default_project`, `recall_limit`, `privacy_filter`, `agent_name`) can also be written to `$HERMES_HOME/plugins/hicortex/config.json` directly. `agent_name` pins the per-agent context id for this profile (leave blank to auto-derive — see [Per-agent standing context](#per-agent-standing-context-013)). The auth token is a **secret** — set it via env, not the JSON file:
 
 ```bash
 export HICORTEX_AUTH_TOKEN=hctx-default-token   # or your custom token

package/hermes-plugin/hicortex/client.py

@@ -96,6 +96,13 @@ class HicortexClient:
     def lessons(self) -> dict[str, Any]:
         return self._get("/lessons")
 
+    def context(self, agent: Optional[str] = None) -> dict[str, Any]:
+        """Standing context layer (L2). When ``agent`` is set, the server
+        resolves the per-agent scope and echoes ``agent``/``mode`` (0.13); a
+        pre-0.13 server ignores the param and returns the global set with no
+        echo — the caller uses that echo as an old-server guard."""
+        return self._get("/context", {"agent": agent})
+
     def index(self) -> dict[str, Any]:
         return self._get("/index")
 

package/hermes-plugin/hicortex/config.py

@@ -57,6 +57,16 @@ CONFIG_SCHEMA: list[dict[str, Any]] = [
         "default": "WORK,PERSONAL",
         "required": False,
     },
+    {
+        "key": "agent_name",
+        "label": "Agent name (per-agent context)",
+        "description": (
+            "Identity sent as ?agent= when fetching the standing context layer, "
+            "so this profile gets its own context (0.13). Leave blank to "
+            "auto-derive from the running profile (HERMES_PROFILE / HERMES_HOME)."
+        ),
+        "required": False,
+    },
     # NOTE: recall-only plugin — no capture config. Capture is handled by the
     # nightly server-side reader of each agent's session store.
 ]

package/hermes-plugin/hicortex/plugin.yaml

@@ -1,6 +1,6 @@
 name: hicortex
-version: 0.5.0
-description: "Self-learning memory for Hermes agents — every session is distilled into lessons overnight, and your agent wakes up wiser. Injects fresh lessons each turn and exposes the full 8-tool memory surface (search, recent, ingest, lessons, index, graph, update, delete) via a shared Hicortex server. Stdlib-only."
+version: 0.6.0
+description: "Self-learning memory for Hermes agents — every session is distilled into lessons overnight, and your agent wakes up wiser. Injects fresh lessons each turn plus a per-agent standing context block, and exposes the full 8-tool memory surface (search, recent, ingest, lessons, index, graph, update, delete) via a shared Hicortex server. Stdlib-only."
 pip_dependencies: []
 hooks: []
 requires_env: