@remnic/core 1.1.0 → 1.1.2

package/dist/access-schema.d.ts

@@ -9,6 +9,28 @@ interface SchemaValidationError {
     }>;
 }
 declare function formatZodError(error: z.ZodError): SchemaValidationError;
+/**
+ * Coding-agent context (issue #569). Optional payload that connectors may
+ * ship with a recall request so the project/branch namespace overlay
+ * applies to that recall. All fields are validated per CLAUDE.md #51 —
+ * empty-string projectId / rootPath is rejected, not silently accepted.
+ */
+declare const codingContextSchema: z.ZodNullable<z.ZodObject<{
+    projectId: z.ZodString;
+    branch: z.ZodNullable<z.ZodString>;
+    rootPath: z.ZodString;
+    defaultBranch: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    projectId: string;
+    branch: string | null;
+    rootPath: string;
+    defaultBranch: string | null;
+}, {
+    projectId: string;
+    branch: string | null;
+    rootPath: string;
+    defaultBranch: string | null;
+}>>;
 declare const recallRequestSchema: z.ZodObject<{
     query: z.ZodString;
     sessionKey: z.ZodOptional<z.ZodString>;
@@ -16,30 +38,98 @@ declare const recallRequestSchema: z.ZodObject<{
     topK: z.ZodOptional<z.ZodNumber>;
     mode: z.ZodOptional<z.ZodEnum<["auto", "no_recall", "minimal", "full", "graph_mode"]>>;
     includeDebug: z.ZodOptional<z.ZodBoolean>;
+    codingContext: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        projectId: z.ZodString;
+        branch: z.ZodNullable<z.ZodString>;
+        rootPath: z.ZodString;
+        defaultBranch: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        projectId: string;
+        branch: string | null;
+        rootPath: string;
+        defaultBranch: string | null;
+    }, {
+        projectId: string;
+        branch: string | null;
+        rootPath: string;
+        defaultBranch: string | null;
+    }>>>;
 }, "strip", z.ZodTypeAny, {
     query: string;
-    namespace?: string | undefined;
     sessionKey?: string | undefined;
+    namespace?: string | undefined;
     topK?: number | undefined;
     mode?: "no_recall" | "minimal" | "full" | "graph_mode" | "auto" | undefined;
+    codingContext?: {
+        projectId: string;
+        branch: string | null;
+        rootPath: string;
+        defaultBranch: string | null;
+    } | null | undefined;
     includeDebug?: boolean | undefined;
 }, {
     query: string;
-    namespace?: string | undefined;
     sessionKey?: string | undefined;
+    namespace?: string | undefined;
     topK?: number | undefined;
     mode?: "no_recall" | "minimal" | "full" | "graph_mode" | "auto" | undefined;
+    codingContext?: {
+        projectId: string;
+        branch: string | null;
+        rootPath: string;
+        defaultBranch: string | null;
+    } | null | undefined;
     includeDebug?: boolean | undefined;
 }>;
 declare const recallExplainRequestSchema: z.ZodObject<{
     sessionKey: z.ZodOptional<z.ZodString>;
     namespace: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    namespace?: string | undefined;
     sessionKey?: string | undefined;
-}, {
     namespace?: string | undefined;
+}, {
     sessionKey?: string | undefined;
+    namespace?: string | undefined;
+}>;
+/**
+ * Standalone "set coding context" request. Used by the HTTP endpoint
+ * `POST /engram/v1/coding-context` and the MCP `remnic.set_coding_context`
+ * tool (PR 7). `codingContext: null` clears the attached context.
+ */
+declare const setCodingContextRequestSchema: z.ZodObject<{
+    sessionKey: z.ZodString;
+    codingContext: z.ZodNullable<z.ZodObject<{
+        projectId: z.ZodString;
+        branch: z.ZodNullable<z.ZodString>;
+        rootPath: z.ZodString;
+        defaultBranch: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        projectId: string;
+        branch: string | null;
+        rootPath: string;
+        defaultBranch: string | null;
+    }, {
+        projectId: string;
+        branch: string | null;
+        rootPath: string;
+        defaultBranch: string | null;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    sessionKey: string;
+    codingContext: {
+        projectId: string;
+        branch: string | null;
+        rootPath: string;
+        defaultBranch: string | null;
+    } | null;
+}, {
+    sessionKey: string;
+    codingContext: {
+        projectId: string;
+        branch: string | null;
+        rootPath: string;
+        defaultBranch: string | null;
+    } | null;
 }>;
 declare const observeRequestSchema: z.ZodObject<{
     sessionKey: z.ZodString;
@@ -78,7 +168,7 @@ declare const memoryStoreRequestSchema: z.ZodObject<{
     dryRun: z.ZodOptional<z.ZodBoolean>;
     sessionKey: z.ZodOptional<z.ZodString>;
     content: z.ZodString;
-    category: z.ZodOptional<z.ZodEnum<["fact", "preference", "correction", "entity", "decision", "relationship", "principle", "commitment", "moment", "skill", "rule", "procedure"]>>;
+    category: z.ZodOptional<z.ZodEnum<["fact", "preference", "correction", "entity", "decision", "relationship", "principle", "commitment", "moment", "skill", "rule", "procedure", "reasoning_trace"]>>;
     confidence: z.ZodOptional<z.ZodNumber>;
     namespace: z.ZodOptional<z.ZodString>;
     tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -87,28 +177,28 @@ declare const memoryStoreRequestSchema: z.ZodObject<{
     sourceReason: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     content: string;
-    namespace?: string | undefined;
-    category?: "fact" | "preference" | "correction" | "entity" | "decision" | "relationship" | "principle" | "commitment" | "moment" | "skill" | "rule" | "procedure" | undefined;
-    confidence?: number | undefined;
-    ttl?: string | undefined;
     schemaVersion?: number | undefined;
     sessionKey?: string | undefined;
     tags?: string[] | undefined;
+    namespace?: string | undefined;
+    category?: "fact" | "preference" | "correction" | "entity" | "decision" | "relationship" | "principle" | "commitment" | "moment" | "skill" | "rule" | "procedure" | "reasoning_trace" | undefined;
+    confidence?: number | undefined;
     entityRef?: string | undefined;
     dryRun?: boolean | undefined;
+    ttl?: string | undefined;
     sourceReason?: string | undefined;
     idempotencyKey?: string | undefined;
 }, {
     content: string;
-    namespace?: string | undefined;
-    category?: "fact" | "preference" | "correction" | "entity" | "decision" | "relationship" | "principle" | "commitment" | "moment" | "skill" | "rule" | "procedure" | undefined;
-    confidence?: number | undefined;
-    ttl?: string | undefined;
     schemaVersion?: number | undefined;
     sessionKey?: string | undefined;
     tags?: string[] | undefined;
+    namespace?: string | undefined;
+    category?: "fact" | "preference" | "correction" | "entity" | "decision" | "relationship" | "principle" | "commitment" | "moment" | "skill" | "rule" | "procedure" | "reasoning_trace" | undefined;
+    confidence?: number | undefined;
     entityRef?: string | undefined;
     dryRun?: boolean | undefined;
+    ttl?: string | undefined;
     sourceReason?: string | undefined;
     idempotencyKey?: string | undefined;
 }>;
@@ -118,7 +208,7 @@ declare const suggestionSubmitRequestSchema: z.ZodObject<{
     dryRun: z.ZodOptional<z.ZodBoolean>;
     sessionKey: z.ZodOptional<z.ZodString>;
     content: z.ZodString;
-    category: z.ZodOptional<z.ZodEnum<["fact", "preference", "correction", "entity", "decision", "relationship", "principle", "commitment", "moment", "skill", "rule", "procedure"]>>;
+    category: z.ZodOptional<z.ZodEnum<["fact", "preference", "correction", "entity", "decision", "relationship", "principle", "commitment", "moment", "skill", "rule", "procedure", "reasoning_trace"]>>;
     confidence: z.ZodOptional<z.ZodNumber>;
     namespace: z.ZodOptional<z.ZodString>;
     tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -127,28 +217,28 @@ declare const suggestionSubmitRequestSchema: z.ZodObject<{
     sourceReason: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     content: string;
-    namespace?: string | undefined;
-    category?: "fact" | "preference" | "correction" | "entity" | "decision" | "relationship" | "principle" | "commitment" | "moment" | "skill" | "rule" | "procedure" | undefined;
-    confidence?: number | undefined;
-    ttl?: string | undefined;
     schemaVersion?: number | undefined;
     sessionKey?: string | undefined;
     tags?: string[] | undefined;
+    namespace?: string | undefined;
+    category?: "fact" | "preference" | "correction" | "entity" | "decision" | "relationship" | "principle" | "commitment" | "moment" | "skill" | "rule" | "procedure" | "reasoning_trace" | undefined;
+    confidence?: number | undefined;
     entityRef?: string | undefined;
     dryRun?: boolean | undefined;
+    ttl?: string | undefined;
     sourceReason?: string | undefined;
     idempotencyKey?: string | undefined;
 }, {
     content: string;
-    namespace?: string | undefined;
-    category?: "fact" | "preference" | "correction" | "entity" | "decision" | "relationship" | "principle" | "commitment" | "moment" | "skill" | "rule" | "procedure" | undefined;
-    confidence?: number | undefined;
-    ttl?: string | undefined;
     schemaVersion?: number | undefined;
     sessionKey?: string | undefined;
     tags?: string[] | undefined;
+    namespace?: string | undefined;
+    category?: "fact" | "preference" | "correction" | "entity" | "decision" | "relationship" | "principle" | "commitment" | "moment" | "skill" | "rule" | "procedure" | "reasoning_trace" | undefined;
+    confidence?: number | undefined;
     entityRef?: string | undefined;
     dryRun?: boolean | undefined;
+    ttl?: string | undefined;
     sourceReason?: string | undefined;
     idempotencyKey?: string | undefined;
 }>;
@@ -180,17 +270,17 @@ declare const trustZonePromoteRequestSchema: z.ZodObject<{
     recordId: string;
     targetZone: "working" | "trusted";
     promotionReason: string;
-    namespace?: string | undefined;
     recordedAt?: string | undefined;
     summary?: string | undefined;
+    namespace?: string | undefined;
     dryRun?: boolean | undefined;
 }, {
     recordId: string;
     targetZone: "working" | "trusted";
     promotionReason: string;
-    namespace?: string | undefined;
     recordedAt?: string | undefined;
     summary?: string | undefined;
+    namespace?: string | undefined;
     dryRun?: boolean | undefined;
 }>;
 declare const trustZoneDemoSeedRequestSchema: z.ZodObject<{
@@ -199,13 +289,13 @@ declare const trustZoneDemoSeedRequestSchema: z.ZodObject<{
     dryRun: z.ZodOptional<z.ZodBoolean>;
     namespace: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    namespace?: string | undefined;
     recordedAt?: string | undefined;
+    namespace?: string | undefined;
     dryRun?: boolean | undefined;
     scenario?: string | undefined;
 }, {
-    namespace?: string | undefined;
     recordedAt?: string | undefined;
+    namespace?: string | undefined;
     dryRun?: boolean | undefined;
     scenario?: string | undefined;
 }>;
@@ -216,30 +306,31 @@ declare const lcmSearchRequestSchema: z.ZodObject<{
     limit: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     query: string;
+    sessionKey?: string | undefined;
     namespace?: string | undefined;
     limit?: number | undefined;
-    sessionKey?: string | undefined;
 }, {
     query: string;
+    sessionKey?: string | undefined;
     namespace?: string | undefined;
     limit?: number | undefined;
-    sessionKey?: string | undefined;
 }>;
 declare const daySummaryRequestSchema: z.ZodObject<{
     memories: z.ZodOptional<z.ZodString>;
     sessionKey: z.ZodOptional<z.ZodString>;
     namespace: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    namespace?: string | undefined;
     sessionKey?: string | undefined;
+    namespace?: string | undefined;
     memories?: string | undefined;
 }, {
-    namespace?: string | undefined;
     sessionKey?: string | undefined;
+    namespace?: string | undefined;
     memories?: string | undefined;
 }>;
 type RecallRequest = z.infer<typeof recallRequestSchema>;
 type RecallExplainRequest = z.infer<typeof recallExplainRequestSchema>;
+type SetCodingContextRequest = z.infer<typeof setCodingContextRequestSchema>;
 type ObserveRequest = z.infer<typeof observeRequestSchema>;
 type MemoryStoreRequest = z.infer<typeof memoryStoreRequestSchema>;
 type SuggestionSubmitRequest = z.infer<typeof suggestionSubmitRequestSchema>;
@@ -248,8 +339,8 @@ type TrustZonePromoteRequest = z.infer<typeof trustZonePromoteRequestSchema>;
 type TrustZoneDemoSeedRequest = z.infer<typeof trustZoneDemoSeedRequestSchema>;
 type LcmSearchRequest = z.infer<typeof lcmSearchRequestSchema>;
 type DaySummaryRequest = z.infer<typeof daySummaryRequestSchema>;
-type SchemaName = "recall" | "recallExplain" | "observe" | "memoryStore" | "suggestionSubmit" | "reviewDisposition" | "trustZonePromote" | "trustZoneDemoSeed" | "lcmSearch" | "daySummary";
-type SchemaTypeFor<N extends SchemaName> = N extends "recall" ? RecallRequest : N extends "recallExplain" ? RecallExplainRequest : N extends "observe" ? ObserveRequest : N extends "memoryStore" ? MemoryStoreRequest : N extends "suggestionSubmit" ? SuggestionSubmitRequest : N extends "reviewDisposition" ? ReviewDispositionRequest : N extends "trustZonePromote" ? TrustZonePromoteRequest : N extends "trustZoneDemoSeed" ? TrustZoneDemoSeedRequest : N extends "lcmSearch" ? LcmSearchRequest : N extends "daySummary" ? DaySummaryRequest : never;
+type SchemaName = "recall" | "recallExplain" | "setCodingContext" | "observe" | "memoryStore" | "suggestionSubmit" | "reviewDisposition" | "trustZonePromote" | "trustZoneDemoSeed" | "lcmSearch" | "daySummary";
+type SchemaTypeFor<N extends SchemaName> = N extends "recall" ? RecallRequest : N extends "recallExplain" ? RecallExplainRequest : N extends "setCodingContext" ? SetCodingContextRequest : N extends "observe" ? ObserveRequest : N extends "memoryStore" ? MemoryStoreRequest : N extends "suggestionSubmit" ? SuggestionSubmitRequest : N extends "reviewDisposition" ? ReviewDispositionRequest : N extends "trustZonePromote" ? TrustZonePromoteRequest : N extends "trustZoneDemoSeed" ? TrustZoneDemoSeedRequest : N extends "lcmSearch" ? LcmSearchRequest : N extends "daySummary" ? DaySummaryRequest : never;
 /**
  * Validate a request body against the named schema.
  * Returns `{ success: true, data }` on pass or
@@ -263,4 +354,4 @@ declare function validateRequest<T = unknown>(schemaName: SchemaName, body: unkn
     error: SchemaValidationError;
 };
 
-export { type DaySummaryRequest, type LcmSearchRequest, type MemoryStoreRequest, type ObserveRequest, type RecallExplainRequest, type RecallRequest, type ReviewDispositionRequest, type SchemaName, type SchemaTypeFor, type SchemaValidationError, type SuggestionSubmitRequest, type TrustZoneDemoSeedRequest, type TrustZonePromoteRequest, daySummaryRequestSchema, formatZodError, lcmSearchRequestSchema, memoryStoreRequestSchema, observeRequestSchema, recallExplainRequestSchema, recallRequestSchema, reviewDispositionRequestSchema, suggestionSubmitRequestSchema, trustZoneDemoSeedRequestSchema, trustZonePromoteRequestSchema, validateRequest };
+export { type DaySummaryRequest, type LcmSearchRequest, type MemoryStoreRequest, type ObserveRequest, type RecallExplainRequest, type RecallRequest, type ReviewDispositionRequest, type SchemaName, type SchemaTypeFor, type SchemaValidationError, type SetCodingContextRequest, type SuggestionSubmitRequest, type TrustZoneDemoSeedRequest, type TrustZonePromoteRequest, codingContextSchema, daySummaryRequestSchema, formatZodError, lcmSearchRequestSchema, memoryStoreRequestSchema, observeRequestSchema, recallExplainRequestSchema, recallRequestSchema, reviewDispositionRequestSchema, setCodingContextRequestSchema, suggestionSubmitRequestSchema, trustZoneDemoSeedRequestSchema, trustZonePromoteRequestSchema, validateRequest };

package/dist/access-schema.js

@@ -1,4 +1,5 @@
 import {
+  codingContextSchema,
   daySummaryRequestSchema,
   formatZodError,
   lcmSearchRequestSchema,
@@ -7,12 +8,14 @@ import {
   recallExplainRequestSchema,
   recallRequestSchema,
   reviewDispositionRequestSchema,
+  setCodingContextRequestSchema,
   suggestionSubmitRequestSchema,
   trustZoneDemoSeedRequestSchema,
   trustZonePromoteRequestSchema,
   validateRequest
-} from "./chunk-MTLYEMJB.js";
+} from "./chunk-WCLICCGB.js";
 export {
+  codingContextSchema,
   daySummaryRequestSchema,
   formatZodError,
   lcmSearchRequestSchema,
@@ -21,6 +24,7 @@ export {
   recallExplainRequestSchema,
   recallRequestSchema,
   reviewDispositionRequestSchema,
+  setCodingContextRequestSchema,
   suggestionSubmitRequestSchema,
   trustZoneDemoSeedRequestSchema,
   trustZonePromoteRequestSchema,

package/dist/{access-service-HmO1Trrx.d.ts → access-service-Br8ZydTK.d.ts}

@@ -1,80 +1,80 @@
-import { DaySummaryResult, RecallPlanMode, MemoryFile, MemoryLifecycleEvent, EntityFile, MemoryStatus, PluginConfig } from './types.js';
+import { StorageManager } from './storage.js';
+import { RecallXraySnapshot } from './recall-xray.js';
+import { RecallExplainJsonPayload } from './recall-explain-renderer.js';
+import { PluginConfig, DaySummaryResult, RecallPlanMode, MemoryFile, MemoryLifecycleEvent, EntityFile, MemoryStatus } from './types.js';
+import { AnomalyDetectorResult } from './recall-audit-anomaly.js';
 import { ExplicitCaptureInput } from './explicit-capture.js';
+import { BudgetDecision } from './cross-namespace-budget.js';
 import { r as readMemoryGovernanceRunArtifact } from './memory-projection-store-DeSXPh1j.js';
 import { LastRecallSnapshot } from './recall-state.js';
-import { O as Orchestrator, I as IntentDebugSnapshot, G as GraphRecallSnapshot } from './orchestrator-DRYA6_lW.js';
-import { StorageManager } from './storage.js';
+import { O as Orchestrator, I as IntentDebugSnapshot, G as GraphRecallSnapshot, S as SemanticDedupLookup } from './orchestrator-CmJ-NTdJ.js';
 import { TrustZoneStoreStatus, TrustZoneName, TrustZoneRecordKind, TrustZoneSourceClass, TrustZoneProvenanceScore, TrustZonePromotionResult, TrustZoneDemoSeedResult } from './trust-zones.js';
 import { LocalLlmClient } from './local-llm.js';
 import { FallbackLlmClient } from './fallback-llm.js';
+import { MemoryOutcomeKind, RecordMemoryOutcomeResult } from './memory-worth-outcomes.js';
 
 /**
- * @remnic/core — Write-time semantic dedup guard
- *
- * Complements the exact content-hash check in the orchestrator's write path
- * by detecting near-duplicate candidate facts via embedding cosine similarity.
+ * Procedural memory stats surface (issue #567 PR 5/5).
  *
- * The module intentionally has no dependency on the EmbeddingFallback or QMD
- * classes directly — callers pass in a `lookup` function that returns the
- * top-K nearest neighbors with their cosine scores. This keeps the decision
- * logic pure and trivially testable with synthetic fixtures, and lets the
- * orchestrator reuse whichever backend it already has wired up.
+ * Pure helper that tallies procedure memories by status and summarizes the
+ * current `procedural.*` config so operators (and the dashboard) can see,
+ * in one call, how procedural memory is behaving in a namespace.
  *
- * Related issue: joshuaswarren/remnic#373
+ * Consumed by:
+ *   - CLI `remnic procedural stats`
+ *   - HTTP `GET /engram/v1/procedural/stats`
+ *   - MCP `remnic.procedural_stats` (+ `engram.procedural_stats` alias)
  */
-/** A single nearest-neighbor hit from the embedding backend. */
-interface SemanticDedupHit {
-    /** Memory id of the existing neighbor. */
-    id: string;
-    /** Cosine similarity score in [0, 1]. */
-    score: number;
-    /** Optional source path, purely informational. */
-    path?: string;
+
+interface ProcedureStatusCounts {
+    total: number;
+    active: number;
+    pending_review: number;
+    rejected: number;
+    quarantined: number;
+    superseded: number;
+    archived: number;
+    /** Any status the enum doesn't yet cover. */
+    other: number;
+}
+interface ProcedureStatsConfigSnapshot {
+    enabled: boolean;
+    minOccurrences: number;
+    successFloor: number;
+    autoPromoteOccurrences: number;
+    autoPromoteEnabled: boolean;
+    lookbackDays: number;
+    recallMaxProcedures: number;
+}
+interface ProcedureStatsRecent {
+    /** ISO 8601 timestamp of the most recent procedure write, or null. */
+    lastWriteAt: string | null;
+    /** Count of procedure files with `created` (or `updated`) in the last 7 days. */
+    writesLast7Days: number;
+    /** Count of procedures whose `source` is the procedure miner. */
+    minerSourced: number;
+}
+interface ProcedureStatsReport {
+    schemaVersion: 1;
+    generatedAt: string;
+    counts: ProcedureStatusCounts;
+    recent: ProcedureStatsRecent;
+    config: ProcedureStatsConfigSnapshot;
 }
 /**
- * Lookup function passed by the caller. Must return an array of hits sorted
- * descending by score. Implementations should return an empty array (never
- * throw) when the embedding backend is unavailable — the decision function
- * treats that as "no near duplicate" (fail-open).
+ * Read all memories from storage and tally procedures by status + recency.
+ * `nowMs` is injectable so tests can pin the "last 7 days" window.
  */
-type SemanticDedupLookup = (content: string, limit: number) => Promise<SemanticDedupHit[]>;
-interface SemanticDedupOptions {
-    /** Master switch. When false, `decideSemanticDedup` always returns `keep`. */
-    enabled: boolean;
-    /** Cosine similarity threshold (0-1). ≥ threshold ⇒ treat as duplicate. */
-    threshold: number;
-    /** How many nearest neighbors to compare against. */
-    candidates: number;
-}
-type SemanticDedupDecision = {
-    action: "keep";
-    reason: "disabled" | "backend_unavailable" | "no_candidates" | "no_near_duplicate";
-    topScore?: number;
-    topId?: string;
-} | {
-    action: "skip";
-    reason: "near_duplicate";
-    topScore: number;
-    topId: string;
-    topPath?: string;
-};
+declare function computeProcedureStats(options: {
+    storage: StorageManager;
+    config: PluginConfig;
+    nowMs?: number;
+}): Promise<ProcedureStatsReport>;
 /**
- * Pure decision function: given a lookup callback and options, decide whether
- * the candidate content should be written or skipped as a near-duplicate.
- *
- * Contract:
- *   - When `options.enabled` is false → always keep, reason="disabled".
- *   - When the lookup throws (provider down / network error) → keep,
- *     reason="backend_unavailable". Fail-open: a lookup failure must not block
- *     writes.
- *   - When the lookup succeeds but returns 0 hits (empty index or no
- *     neighbors above the score floor) → keep, reason="no_candidates".
- *     This is distinct from backend_unavailable so telemetry dashboards can
- *     correctly distinguish "provider is down" from "index is empty".
- *   - When the top hit's score ≥ threshold → skip with reason="near_duplicate".
- *   - Otherwise → keep with reason="no_near_duplicate".
+ * Render `ProcedureStatsReport` as a human-friendly plain-text block for CLI
+ * operators. Keep it deterministic — no colors, no ANSI. Used by `--format text`.
  */
-declare function decideSemanticDedup(content: string, lookup: SemanticDedupLookup, options: SemanticDedupOptions): Promise<SemanticDedupDecision>;
+declare function formatProcedureStatsText(report: ProcedureStatsReport): string;
 
 declare class EngramAccessInputError extends Error {
 }
@@ -96,6 +96,34 @@ interface EngramAccessRecallRequest {
     topK?: number;
     mode?: RecallPlanMode | "auto";
     includeDebug?: boolean;
+    /**
+     * Coding-agent context (issue #569). When a connector resolves a git
+     * context for the session's cwd, it passes it here and the access service
+     * attaches it to the orchestrator before recall so project- / branch-
+     * scoped namespace overlays apply.
+     *
+     * Keyed by `sessionKey`; ignored when `sessionKey` is absent.
+     */
+    codingContext?: {
+        projectId: string;
+        branch: string | null;
+        rootPath: string;
+        defaultBranch: string | null;
+    } | null;
+}
+/**
+ * Standalone request to attach / clear the coding context for a session
+ * without performing a recall. Used by the Claude Code / Codex connectors
+ * at session start, and by the `remnic.set_coding_context` MCP tool (PR 7).
+ */
+interface EngramAccessSetCodingContextRequest {
+    sessionKey: string;
+    codingContext: {
+        projectId: string;
+        branch: string | null;
+        rootPath: string;
+        defaultBranch: string | null;
+    } | null;
 }
 interface EngramAccessRecallResponse {
     query: string;
@@ -111,6 +139,8 @@ interface EngramAccessRecallResponse {
     fallbackUsed: boolean;
     sourcesUsed: string[];
     budgetsApplied?: LastRecallSnapshot["budgetsApplied"];
+    auditAnomalies?: AnomalyDetectorResult;
+    budgetWarning?: BudgetDecision;
     latencyMs?: number;
     debug?: {
         snapshot?: LastRecallSnapshot;
@@ -424,6 +454,8 @@ declare class EngramAccessService {
     private readonly orchestrator;
     private readonly idempotency;
     private readonly idempotencyLocks;
+    private readonly budget;
+    private readonly auditAdapter;
     constructor(orchestrator: Orchestrator);
     get briefingEnabled(): boolean;
     private resolveNamespace;
@@ -444,8 +476,39 @@ declare class EngramAccessService {
      * or Responses API is unavailable — never throws for LLM-related problems.
      */
     briefing(request: EngramAccessBriefingRequest): Promise<EngramAccessBriefingResponse>;
+    /**
+     * Attach a coding context to a session (issue #569). Used by the Claude
+     * Code / Codex / generic-MCP connectors at session start so that recall +
+     * write paths can route to a project- / branch-scoped namespace.
+     *
+     * Validates the input shape and rejects malformed payloads rather than
+     * silently accepting them (CLAUDE.md #51). Pass `codingContext: null` to
+     * clear.
+     */
+    setCodingContext(request: EngramAccessSetCodingContextRequest): void;
     recall(request: EngramAccessRecallRequest): Promise<EngramAccessRecallResponse>;
     recallExplain(request?: EngramAccessRecallExplainRequest): Promise<EngramAccessRecallExplainResponse>;
+    recallTierExplain(sessionKey?: string, namespace?: string, authenticatedPrincipal?: string): Promise<RecallExplainJsonPayload>;
+    /**
+     * Recall X-ray (issue #570).  Runs a recall with `xrayCapture: true`
+     * and returns the resulting snapshot as structured JSON so every
+     * surface (CLI / HTTP / MCP) gets the same payload.  Namespace scope
+     * is enforced before the recall fires (CLAUDE.md rule 42 — read and
+     * write paths must resolve through the same namespace layer) so an
+     * unauthorized principal cannot capture an x-ray for a namespace it
+     * cannot read.
+     */
+    recallXray(request: {
+        query: string;
+        sessionKey?: string;
+        namespace?: string;
+        budget?: number;
+        authenticatedPrincipal?: string;
+    }): Promise<{
+        snapshotFound: boolean;
+        snapshot?: RecallXraySnapshot;
+    }>;
+    private xrayQueue;
     memoryStore(request: EngramAccessMemoryStoreRequest): Promise<EngramAccessWriteResponse>;
     peekMemoryStoreIdempotency(request: EngramAccessMemoryStoreRequest): Promise<EngramAccessIdempotencyStatus>;
     suggestionSubmit(request: EngramAccessSuggestionSubmitRequest): Promise<EngramAccessWriteResponse>;
@@ -491,6 +554,16 @@ declare class EngramAccessService {
         proceduresWritten: number;
         skippedReason?: string;
     }>;
+    /**
+     * Procedural memory stats (issue #567 PR 5/5). Read-only — resolves the
+     * namespace via the same path used by `recallExplain` / `trustZoneStatus`
+     * so cross-tenant reads are impossible (CLAUDE.md rule 42).
+     */
+    procedureStats(request?: {
+        namespace?: string;
+    }, principal?: string): Promise<ProcedureStatsReport & {
+        namespace: string;
+    }>;
     trustZoneStatus(namespace?: string, principal?: string): Promise<EngramAccessTrustZoneStatusResponse>;
     trustZoneBrowse(request: EngramAccessTrustZoneBrowseRequest, principal?: string): Promise<EngramAccessTrustZoneBrowseResponse>;
     trustZonePromote(request: EngramAccessTrustZonePromoteRequest): Promise<EngramAccessTrustZonePromoteResponse>;
@@ -685,6 +758,28 @@ declare class EngramAccessService {
         enabled?: boolean;
         reason?: string;
     }>;
+    /**
+     * Record a Memory Worth outcome observation (issue #560 PR 3).
+     *
+     * This is distinct from `memoryFeedback` — feedback is a human thumbs
+     * up/down on whether a recalled memory was relevant; outcome is an
+     * automated signal about whether the session that consumed the memory
+     * ultimately succeeded or failed. Outcomes feed the Laplace-smoothed
+     * worth score (`computeMemoryWorth`, PR 2) that PR 4 will use to
+     * downweight memories correlated with bad sessions.
+     *
+     * The underlying writer only touches fact-category memories. Corrections,
+     * procedures, and other kinds return `{ ok: false, reason:
+     * "ineligible_category" }` so a ledger drainer doesn't need to pre-filter.
+     */
+    memoryOutcome(request: {
+        memoryId: string;
+        outcome: MemoryOutcomeKind;
+        namespace?: string;
+        principal?: string;
+        sessionKey?: string;
+        timestamp?: string;
+    }): Promise<RecordMemoryOutcomeResult>;
     memoryPromote(request: {
         memoryId: string;
         namespace?: string;
@@ -726,7 +821,7 @@ declare class EngramAccessService {
     get configRef(): PluginConfig;
     get localLlmRef(): LocalLlmClient | null;
     get fallbackLlmRef(): FallbackLlmClient | null;
-    get embeddingLookupRef(): SemanticDedupLookup | undefined;
+    get embeddingLookupFactoryRef(): (storage: StorageManager) => SemanticDedupLookup | undefined;
 }
 
-export { type EngramAccessRecallExplainRequest as A, type EngramAccessRecallExplainResponse as B, type EngramAccessRecallRequest as C, type EngramAccessRecallResponse as D, EngramAccessService as E, type EngramAccessReviewDispositionRequest as F, type EngramAccessReviewDispositionResponse as G, type EngramAccessReviewQueueResponse as H, type EngramAccessSuggestionSubmitRequest as I, type EngramAccessTimelineResponse as J, type EngramAccessTrustZoneBrowseRequest as K, type EngramAccessTrustZoneBrowseResponse as L, type EngramAccessTrustZoneDemoSeedRequest as M, type EngramAccessTrustZoneDemoSeedResponse as N, type EngramAccessTrustZonePromoteRequest as O, type EngramAccessTrustZonePromoteResponse as P, type EngramAccessTrustZoneRecordSummary as Q, type EngramAccessTrustZoneStatusResponse as R, type SemanticDedupDecision as S, type EngramAccessWriteEnvelope as T, type EngramAccessWriteResponse as U, EngramAccessInputError as a, type SemanticDedupHit as b, type SemanticDedupLookup as c, type SemanticDedupOptions as d, decideSemanticDedup as e, ENGRAM_ACCESS_WRITE_SCHEMA_VERSION as f, type EngramAccessBriefingRequest as g, type EngramAccessBriefingResponse as h, type EngramAccessDaySummaryRequest as i, type EngramAccessEntityListResponse as j, type EngramAccessEntityResponse as k, type EngramAccessEntitySummary as l, type EngramAccessHealthResponse as m, type EngramAccessLcmSearchRequest as n, type EngramAccessLcmSearchResponse as o, type EngramAccessLcmStatusResponse as p, type EngramAccessMaintenanceResponse as q, type EngramAccessMemoryBrowseRequest as r, type EngramAccessMemoryBrowseResponse as s, type EngramAccessMemoryRecord as t, type EngramAccessMemoryResponse as u, type EngramAccessMemoryStoreRequest as v, type EngramAccessMemorySummary as w, type EngramAccessObserveRequest as x, type EngramAccessObserveResponse as y, type EngramAccessQualityResponse as z };
+export { type EngramAccessQualityResponse as A, type EngramAccessRecallExplainRequest as B, type EngramAccessRecallExplainResponse as C, type EngramAccessRecallRequest as D, EngramAccessService as E, type EngramAccessRecallResponse as F, type EngramAccessReviewDispositionRequest as G, type EngramAccessReviewDispositionResponse as H, type EngramAccessReviewQueueResponse as I, type EngramAccessSetCodingContextRequest as J, type EngramAccessSuggestionSubmitRequest as K, type EngramAccessTimelineResponse as L, type EngramAccessTrustZoneBrowseRequest as M, type EngramAccessTrustZoneBrowseResponse as N, type EngramAccessTrustZoneDemoSeedRequest as O, type ProcedureStatsConfigSnapshot as P, type EngramAccessTrustZoneDemoSeedResponse as Q, type EngramAccessTrustZonePromoteRequest as R, type EngramAccessTrustZonePromoteResponse as S, type EngramAccessTrustZoneRecordSummary as T, type EngramAccessTrustZoneStatusResponse as U, type EngramAccessWriteEnvelope as V, type EngramAccessWriteResponse as W, EngramAccessInputError as a, type ProcedureStatsRecent as b, type ProcedureStatsReport as c, type ProcedureStatusCounts as d, computeProcedureStats as e, formatProcedureStatsText as f, ENGRAM_ACCESS_WRITE_SCHEMA_VERSION as g, type EngramAccessBriefingRequest as h, type EngramAccessBriefingResponse as i, type EngramAccessDaySummaryRequest as j, type EngramAccessEntityListResponse as k, type EngramAccessEntityResponse as l, type EngramAccessEntitySummary as m, type EngramAccessHealthResponse as n, type EngramAccessLcmSearchRequest as o, type EngramAccessLcmSearchResponse as p, type EngramAccessLcmStatusResponse as q, type EngramAccessMaintenanceResponse as r, type EngramAccessMemoryBrowseRequest as s, type EngramAccessMemoryBrowseResponse as t, type EngramAccessMemoryRecord as u, type EngramAccessMemoryResponse as v, type EngramAccessMemoryStoreRequest as w, type EngramAccessMemorySummary as x, type EngramAccessObserveRequest as y, type EngramAccessObserveResponse as z };