pi-chalin 0.1.0 → 0.2.0

package/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <a href="package.json"><img alt="version" src="https://img.shields.io/badge/version-0.1.0-111111?style=for-the-badge"></a>
+  <a href="package.json"><img alt="version" src="https://img.shields.io/badge/version-0.2.0-111111?style=for-the-badge"></a>
   <a href="package.json"><img alt="license" src="https://img.shields.io/badge/license-MIT-0f766e?style=for-the-badge"></a>
   <a href="package.json"><img alt="bun" src="https://img.shields.io/badge/bun-%3E%3D1.3.14-111111?style=for-the-badge&logo=bun&logoColor=white"></a>
   <a href="package.json"><img alt="typescript" src="https://img.shields.io/badge/typescript-6.0-3178c6?style=for-the-badge&logo=typescript&logoColor=white"></a>
@@ -31,7 +31,7 @@ Use it when a task benefits from:
 - deeper repository discovery before implementation;
 - isolated planning, execution, and review roles;
 - resumable long-running work;
-- local memory with explicit review;
+- first-class memory through either pi-chalin local review or native Engram;
 - visible routing, safety, and runtime state in the Pi TUI;
 - audited web context for current external information.
 
@@ -42,7 +42,7 @@ Use it when a task benefits from:
 | Routing | Direct execution for bounded work, chalin workflows for broad or risky work. |
 | Subagents | Built-in `scout`, `planner`, `worker`, `reviewer`, `researcher`, `delegate`, `oracle`, `context-builder`, and `conflict-resolver` agents. |
 | Topologies | `single`, `chain`, `parallel`, `dag`, and `memory-only` workflow shapes. |
-| Memory | Local records, candidates, approval/rejection, deduplication, revisions, and FTS-backed search. |
+| Memory | First-class `pi-chalin local`, `engram`, or `auto` backends with search, write, revise, review, and cloud-aware Engram sync. |
 | Artifacts | Resumable checkpoints, validation contracts, interviews, and handoffs. |
 | Safety | Approval thresholds, autonomy modes, recursion guards, single-writer isolation, stale-run recovery, and mutation checks. |
 | TUI | Smart Panel, agent manager, activity monitor, memory review, artifact panel, and web fetch audit. |
@@ -99,11 +99,12 @@ Once Pi loads the package, use `/chalin` inside a Pi session.
 | `/chalin off` | Disable autonomous routing for the current project. |
 | `/chalin agents` | Open the agent manager. |
 | `/chalin memory` | Review memory records and pending candidates. |
-| `/chalin memory <query>` | Search local memory. |
+| `/chalin memory <query>` | Search the configured memory backend. |
 | `/chalin artifacts` | Open artifact and resumable task context. |
 | `/chalin artifacts <feature>` | Resume context for a specific feature artifact. |
 | `/chalin activity` | Inspect the active or latest run. |
 | `/chalin web` | Open the web fetch audit panel. |
+| `/chalin settings` | Choose the memory provider: `auto`, `engram`, or `pi-chalin` local. |
 | `/chalin status` | Print routing, autonomy, safety, agent, memory, and guard status. |
 
 ## Tools
@@ -150,6 +151,7 @@ src/runner.ts             mock and SDK-backed worker execution
 src/agents.ts             built-in, project, and user agent catalog
 src/config.ts             config, autonomy, safety, and overrides
 src/memory.ts             memory records, candidates, and search
+src/memory-provider.ts    configurable pi-chalin local and Engram memory backends
 src/artifacts.ts          resumable task state and handoffs
 src/webfetch.ts           audited external context
 src/worktrees.ts          isolated writer worktrees
@@ -207,6 +209,42 @@ Project-local runtime files live under `.pi-chalin/`:
 .pi-chalin/runs/
 ```
 
+Memory can run against pi-chalin's local SQLite store or Engram. Configure it in `.pi-chalin/config.json` or through `/chalin settings`:
+
+```json
+{
+  "memory": {
+    "provider": "auto",
+    "engram": {
+      "baseUrl": "http://127.0.0.1:7437",
+      "command": "engram",
+      "autoStart": false,
+      "autoSync": true,
+      "syncThrottleMs": 30000,
+      "timeoutMs": 800
+    }
+  }
+}
+```
+
+`auto` uses Engram when the HTTP service is reachable and falls back to local memory. `engram` uses Engram as the memory source for `/chalin memory`; the `baseUrl` may point at any Engram local-runtime-compatible endpoint, including a remote `engram serve` instance. Engram Cloud is supported through Engram's local-first sync model: run `engram serve` against a cloud-enrolled/synced Engram store, then point pi-chalin at that runtime. When `autoSync` is enabled and the configured Engram runtime is local, pi-chalin checks `/sync/status` and runs the official `engram sync --cloud --import --project <project>` before reads, then `engram sync --cloud --project <project>` after writes. This uses `ENGRAM_CLOUD_TOKEN` from the runtime environment and never persists the token.
+
+If the user already has `gentle-pi`/`gentle-engram` working, pi-chalin reuses that Engram runtime. No MCP bootstrap command is required from pi-chalin: choose `engram` in `/chalin settings`, and pi-chalin will use `ENGRAM_URL`, `ENGRAM_PORT`, `ENGRAM_BIN`, the default `http://127.0.0.1:7437` runtime, and Engram's own project detection. If Engram Cloud is enrolled and the Pi process has `ENGRAM_CLOUD_TOKEN`, reads automatically import pending cloud chunks before listing/searching memory.
+
+When Engram is the active/preferred memory provider, `/chalin memory` lists Engram observations only, including project and personal scopes returned by Engram. pi-chalin does not expose its local `approve`/`reject` review flow in that mode. If the user selects `pi-chalin local`, the local SQLite memory store keeps its existing pending-review, approve, reject, delete, search, and revise behavior.
+
+### Engram Memory
+
+Engram is supported as a native memory backend, not as an external afterthought. When `/chalin settings` is set to `engram`, every memory-facing surface uses Engram directly:
+
+- `/chalin memory` lists and searches Engram observations.
+- `chalin_memory_search`, `chalin_memory_write`, and `chalin_memory_revise` operate against Engram.
+- Routed, chained, parallel, DAG, and `memory-only` workflows receive memory from the configured Engram backend.
+- Engram-backed memory does not use pi-chalin's local pending `approve`/`reject` queue.
+- Engram Cloud works through Engram's official local-first sync path when the runtime is enrolled and the Pi process has `ENGRAM_CLOUD_TOKEN`.
+
+Use `auto` when you want Engram if it is reachable with a local fallback, `engram` when Engram must be the source of truth, and `pi-chalin` when you want the local SQLite review workflow.
+
 User-level configuration and agents currently live under `~/.pi/chalin/`. That path is part of the Pi chalin workflow namespace, not the package name.
 
 ## Environment Variables
@@ -221,6 +259,11 @@ PI_CHALIN_MOCK_STEP_DELAY_MS
 PI_CHALIN_WORKFLOW_MODEL
 PI_CHALIN_WORKFLOW_THINKING
 PI_CHALIN_WORKFLOW_GATES
+PI_CHALIN_MEMORY_PROVIDER
+ENGRAM_URL
+ENGRAM_PORT
+ENGRAM_BIN
+ENGRAM_CLOUD_TOKEN
 ```
 
 See `package.json` and the evaluator files under `evals/` for the full set used by development scripts.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-chalin",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Pi Coding Agent extension for routed, memory-aware subagent workflows",
   "license": "MIT",
   "repository": {

package/src/autoroute.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { AgentCatalog } from "./agents.ts";
 import { loadEffectiveConfig } from "./config.ts";
-import { MemoryStore } from "./memory.ts";
+import { createConfiguredMemoryStore } from "./memory-provider.ts";
 import { buildCompactChalinCriticalSystemPrompt, buildCompactChalinOrchestratorSystemPrompt, buildCompactChalinResumeSystemPrompt, buildChalinOrchestratorSystemPrompt } from "./orchestration.ts";
 import { isUsableStepHandoff, loadResumableRunState } from "./runner-state.ts";
 import { beginChalinTurn, recordDirectToolCompletion } from "./runtime-state.ts";
@@ -159,7 +159,7 @@ async function globalMemoryContextForPrompt(cwd: string, prompt: string): Promis
   const query = prompt.trim();
   if (query.length < 8) return undefined;
   try {
-    const bundle = await new MemoryStore({ cwd }).retrieve({
+    const bundle = await createConfiguredMemoryStore({ cwd }).retrieve({
       query,
       sourceAgent: "primary-pi-global",
       limit: 5,

package/src/child-tools.ts

@@ -15,7 +15,8 @@ import { Type } from "typebox";
 import { ArtifactStore, type ArtifactFeatureStatus } from "./artifacts.ts";
 import type { BudgetPolicy } from "./budget.ts";
 import { buildProjectDiscoveryIndex, formatProjectDiscoveryIndex } from "./discovery.ts";
-import { createMemoryCandidate, MemoryStore } from "./memory.ts";
+import { createMemoryCandidate } from "./memory.ts";
+import { createConfiguredMemoryStore } from "./memory-provider.ts";
 import { buildProjectSnapshot, formatProjectSnapshot } from "./snapshot.ts";
 import { fetchWebUrls, formatWebBundle, searchWeb } from "./webfetch.ts";
 
@@ -475,7 +476,7 @@ export function createChalinMemorySearchTool(policy: ChildToolPolicy): ToolDefin
       const input = isRecord(params) ? params : {};
       const gate = policy.beforeTool("chalin_memory_search", input);
       if (!gate.allowed) return blockedToolResult(gate.reason);
-      const store = new MemoryStore({ cwd: policy.cwd });
+      const store = createConfiguredMemoryStore({ cwd: policy.cwd });
       const bundle = await store.retrieve({
         query: String(params.query ?? ""),
         sourceAgent: policy.agentName,
@@ -510,7 +511,7 @@ export function createChalinMemoryWriteTool(policy: ChildToolPolicy): ToolDefini
       if (!gate.allowed) return blockedToolResult(gate.reason);
       const validation = validateMemoryWriteParams(params);
       if (!validation.allowed) return blockedToolResult(validation.reason);
-      const store = new MemoryStore({ cwd: policy.cwd });
+      const store = createConfiguredMemoryStore({ cwd: policy.cwd });
       const [record] = await store.submitCandidates([createMemoryCandidate({
         category: params.category,
         content: params.content,
@@ -546,7 +547,7 @@ export function createChalinMemoryReviseTool(policy: ChildToolPolicy): ToolDefin
       if (!gate.allowed) return blockedToolResult(gate.reason);
       const validation = validateMemoryRevisionParams(params);
       if (!validation.allowed) return blockedToolResult(validation.reason);
-      const store = new MemoryStore({ cwd: policy.cwd });
+      const store = createConfiguredMemoryStore({ cwd: policy.cwd });
       const record = await store.revise(params.id, {
         category: params.category,
         content: params.content,

package/src/commands.ts

@@ -1,9 +1,9 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { sessionModelOverrides, sessionThinkingOverrides } from "./agent-overrides.ts";
 import { AgentCatalog } from "./agents.ts";
 import { ArtifactStore } from "./artifacts.ts";
-import { loadEffectiveConfig, writeProjectConfig } from "./config.ts";
-import { MemoryStore } from "./memory.ts";
+import { loadEffectiveConfig, writeProjectConfig, type ChalinConfig, type MemoryProvider } from "./config.ts";
+import { createConfiguredMemoryStore, resolveMemoryBackendStatus, type MemoryBackendStatus } from "./memory-provider.ts";
 import { getActiveRun, getLatestRun } from "./runtime-state.ts";
 import { openAgentManager } from "./ui-agents.ts";
 import {
@@ -20,7 +20,7 @@ export function registerChalinCommands(pi: ExtensionAPI): void {
   pi.registerCommand("chalin", {
     description: "Open pi-chalin Smart Panel or toggle autonomous routing with: /chalin on|off",
     getArgumentCompletions: (prefix) => {
-      const values = ["on", "off", "agents", "memory", "artifacts", "activity", "web", "status"];
+      const values = ["on", "off", "agents", "memory", "artifacts", "activity", "web", "settings", "status"];
       const filtered = values.filter((value) => value.startsWith(prefix.trim()));
       return filtered.length > 0 ? filtered.map((value) => ({ value, label: value })) : null;
     },
@@ -39,11 +39,12 @@ export function registerChalinCommands(pi: ExtensionAPI): void {
 
       const loaded = loadEffectiveConfig({ cwd: ctx.cwd });
       const catalog = AgentCatalog.load({ cwd: ctx.cwd });
-      const memory = new MemoryStore({ cwd: ctx.cwd });
+      const memory = createConfiguredMemoryStore({ cwd: ctx.cwd }, loaded.config);
       const artifacts = new ArtifactStore({ cwd: ctx.cwd });
       const agents = catalog.list();
       const diagnostics = [...loaded.diagnostics, ...catalog.diagnostics.warnings, ...catalog.diagnostics.errors];
       const pendingMemories = await memory.list("pending");
+      const memoryStatus = await resolveMemoryBackendStatus({ cwd: ctx.cwd }, loaded.config);
       const activeRun = getActiveRun();
       const lastRun = getLatestRun();
 
@@ -62,11 +63,15 @@ export function registerChalinCommands(pi: ExtensionAPI): void {
             approve: (id) => void memory.approve(id),
             reject: (id) => void memory.reject(id),
             delete: (id) => void memory.delete(id),
-          });
+          }, memoryReviewOptions(memoryStatus));
         }
         return;
       }
 
+      if (command === "settings") {
+        await openChalinSettings(ctx, loaded.config);
+        return;
+      }
 
       if (command === "artifacts") {
         const featureId = rest.join(" ").trim();
@@ -94,6 +99,8 @@ export function registerChalinCommands(pi: ExtensionAPI): void {
             `routing: ${loaded.config.enabled ? "on" : "off"}`,
             `autonomy: ${loaded.config.autonomy}`,
             `approval threshold: ${loaded.config.safety.approvalRiskThreshold}`,
+            `memory: ${memoryStatus.summary}`,
+            ...(memoryStatus.detail ? [`memory detail: ${memoryStatus.detail}`] : []),
             `agents: ${agents.length}`,
             `pending memory: ${pendingMemories.length}`,
             `last activity: ${lastRun?.id ?? "none"}`,
@@ -120,6 +127,7 @@ export function registerChalinCommands(pi: ExtensionAPI): void {
           pendingApprovals: 0,
           activeRuns: activeRun ? 1 : 0,
           pendingMemoryCandidates: pendingMemories.length,
+          memoryBackend: memoryStatus.summary,
           lastRun,
         },
         agents,
@@ -131,10 +139,69 @@ export function registerChalinCommands(pi: ExtensionAPI): void {
           approve: (id) => void memory.approve(id),
           reject: (id) => void memory.reject(id),
           delete: (id) => void memory.delete(id),
-        }),
+        }, memoryReviewOptions(memoryStatus)),
         onSelectArtifacts: () => openArtifactPanel(ctx, artifacts),
         onSelectWebFetch: async () => openWebFetchAuditPanel(ctx, await listWebFetchAudit({ cwd: ctx.cwd })),
+        onSelectSettings: () => openChalinSettings(ctx, loaded.config),
       });
     },
   });
 }
+
+async function openChalinSettings(ctx: ExtensionContext, config: ChalinConfig): Promise<void> {
+  const current = config.memory.provider;
+  if (!ctx.hasUI) {
+    ctx.ui.notify(`memory provider: ${current}`, "info");
+    return;
+  }
+
+  const selected = await ctx.ui.select("pi-chalin Settings", [`Memory provider · ${labelForMemoryProvider(current)}`, "Close"]);
+  if (!selected?.startsWith("Memory provider")) return;
+
+  const choice = await ctx.ui.select("Memory Provider", [
+    "Auto · Engram when available",
+    "Engram · native Engram memory",
+    "pi-chalin local",
+    "Close",
+  ]);
+  const provider = providerFromSettingsChoice(choice);
+  if (!provider) return;
+
+  const loaded = writeProjectConfig({ cwd: ctx.cwd }, { memory: { provider } } as Partial<ChalinConfig>);
+  const status = await resolveMemoryBackendStatus({ cwd: ctx.cwd }, loaded.config);
+  ctx.ui.notify(`Memory provider set to ${labelForMemoryProvider(provider)}.\nActive: ${status.summary}`, "info");
+}
+
+function providerFromSettingsChoice(choice: string | undefined): MemoryProvider | undefined {
+  if (choice?.startsWith("Auto")) return "auto";
+  if (choice?.startsWith("Engram")) return "engram";
+  if (choice?.startsWith("pi-chalin")) return "pi-chalin";
+  return undefined;
+}
+
+function labelForMemoryProvider(provider: MemoryProvider): string {
+  if (provider === "auto") return "auto";
+  if (provider === "engram") return "engram";
+  return "pi-chalin local";
+}
+
+function memoryReviewOptions(status: MemoryBackendStatus): { title: string; emptyMessage: string } {
+  if (status.configuredProvider === "engram") {
+    return {
+      title: "Engram Memory",
+      emptyMessage: status.engramAvailable
+        ? status.detail ?? "No Engram memory records found."
+        : "Engram memory is selected, but Engram is unavailable. Start Engram or update /chalin settings.",
+    };
+  }
+  if (status.activeProvider === "engram") {
+    return {
+      title: "Engram Memory",
+      emptyMessage: status.detail ?? "No Engram memory records found.",
+    };
+  }
+  return {
+    title: "pi-chalin Memory",
+    emptyMessage: "No pi-chalin memory records found.",
+  };
+}

package/src/config.ts

@@ -6,6 +6,7 @@ import { isAgentThinkingLevel, riskRank, type AgentScope, type AgentThinkingLeve
 export type AutonomyLevel = "low" | "balanced" | "high";
 export type ApprovalRiskThreshold = RouteRisk;
 export type ModelPersistenceTarget = "session" | "project" | "user";
+export type MemoryProvider = "auto" | "engram" | "pi-chalin";
 
 export interface ChalinConfig {
   enabled: boolean;
@@ -22,6 +23,18 @@ export interface ChalinConfig {
     thinkingOverrides: Record<string, AgentThinkingLevel>;
     modelPersistenceDefaults: Record<AgentScope, ModelPersistenceTarget>;
   };
+  memory: {
+    provider: MemoryProvider;
+    engram: {
+      baseUrl: string;
+      command: string;
+      autoStart: boolean;
+      autoSync: boolean;
+      syncThrottleMs: number;
+      timeoutMs: number;
+      project?: string;
+    };
+  };
 }
 
 export interface LoadedChalinConfig {
@@ -49,6 +62,17 @@ export const DEFAULT_CONFIG: ChalinConfig = {
       project: "project",
     },
   },
+  memory: {
+    provider: "auto",
+    engram: {
+      baseUrl: "http://127.0.0.1:7437",
+      command: "engram",
+      autoStart: false,
+      autoSync: true,
+      syncThrottleMs: 30_000,
+      timeoutMs: 800,
+    },
+  },
 };
 
 function isObject(value: unknown): value is Record<string, unknown> {
@@ -118,6 +142,40 @@ function coerceConfig(input: ChalinConfig, diagnostics: string[]): ChalinConfig
       delete config.agents.thinkingOverrides[agentRef];
     }
   }
+  if (!isObject(config.memory)) config.memory = structuredClone(DEFAULT_CONFIG.memory);
+  if (!["auto", "engram", "pi-chalin"].includes(config.memory.provider)) {
+    diagnostics.push(`Invalid memory.provider '${String(config.memory.provider)}'; using '${DEFAULT_CONFIG.memory.provider}'.`);
+    config.memory.provider = DEFAULT_CONFIG.memory.provider;
+  }
+  if (!isObject(config.memory.engram)) config.memory.engram = structuredClone(DEFAULT_CONFIG.memory.engram);
+  if (typeof config.memory.engram.baseUrl !== "string" || !config.memory.engram.baseUrl.trim()) {
+    diagnostics.push(`Invalid memory.engram.baseUrl '${String(config.memory.engram.baseUrl)}'; using '${DEFAULT_CONFIG.memory.engram.baseUrl}'.`);
+    config.memory.engram.baseUrl = DEFAULT_CONFIG.memory.engram.baseUrl;
+  }
+  if (typeof config.memory.engram.command !== "string" || !config.memory.engram.command.trim()) {
+    diagnostics.push(`Invalid memory.engram.command '${String(config.memory.engram.command)}'; using '${DEFAULT_CONFIG.memory.engram.command}'.`);
+    config.memory.engram.command = DEFAULT_CONFIG.memory.engram.command;
+  }
+  if (typeof config.memory.engram.autoStart !== "boolean") {
+    diagnostics.push(`Invalid memory.engram.autoStart '${String(config.memory.engram.autoStart)}'; using '${DEFAULT_CONFIG.memory.engram.autoStart}'.`);
+    config.memory.engram.autoStart = DEFAULT_CONFIG.memory.engram.autoStart;
+  }
+  if (typeof config.memory.engram.autoSync !== "boolean") {
+    diagnostics.push(`Invalid memory.engram.autoSync '${String(config.memory.engram.autoSync)}'; using '${DEFAULT_CONFIG.memory.engram.autoSync}'.`);
+    config.memory.engram.autoSync = DEFAULT_CONFIG.memory.engram.autoSync;
+  }
+  if (!Number.isFinite(config.memory.engram.syncThrottleMs) || config.memory.engram.syncThrottleMs < 0 || config.memory.engram.syncThrottleMs > 300_000) {
+    diagnostics.push(`Invalid memory.engram.syncThrottleMs '${String(config.memory.engram.syncThrottleMs)}'; using '${DEFAULT_CONFIG.memory.engram.syncThrottleMs}'.`);
+    config.memory.engram.syncThrottleMs = DEFAULT_CONFIG.memory.engram.syncThrottleMs;
+  }
+  if (!Number.isFinite(config.memory.engram.timeoutMs) || config.memory.engram.timeoutMs < 100 || config.memory.engram.timeoutMs > 10_000) {
+    diagnostics.push(`Invalid memory.engram.timeoutMs '${String(config.memory.engram.timeoutMs)}'; using '${DEFAULT_CONFIG.memory.engram.timeoutMs}'.`);
+    config.memory.engram.timeoutMs = DEFAULT_CONFIG.memory.engram.timeoutMs;
+  }
+  if (config.memory.engram.project !== undefined && typeof config.memory.engram.project !== "string") {
+    diagnostics.push(`Invalid memory.engram.project '${String(config.memory.engram.project)}'; removing override.`);
+    delete config.memory.engram.project;
+  }
   return config;
 }
 

package/src/index.ts

@@ -35,6 +35,8 @@ export { ArtifactStore } from "./artifacts.ts";
 export { DEFAULT_CONFIG, approvalDecision, loadEffectiveConfig, setAgentModelOverride, setAgentThinkingOverride, writeProjectConfig, writeUserConfig } from "./config.ts";
 export { ChalinKernel } from "./kernel.ts";
 export { MemoryStore, createMemoryCandidate } from "./memory.ts";
+export { EngramMemoryStore, createConfiguredMemoryStore, resolveMemoryBackendStatus } from "./memory-provider.ts";
 export { MockWorkerRunner, SdkWorkerRunner, parseAgentOutput } from "./runner.ts";
 export { resolveChalinPaths } from "./paths.ts";
 export type { AgentDefinition, AgentMemoryPolicy, AgentThinkingLevel, RouteDecision, RoutePlan, RunState, MemoryCandidate, MemoryRecord } from "./schemas.ts";
+export type { MemoryProvider } from "./config.ts";

package/src/kernel.ts

@@ -1,7 +1,8 @@
 import { AgentCatalog } from "./agents.ts";
 import { ArtifactStore } from "./artifacts.ts";
-import { approvalDecision, type ChalinConfig } from "./config.ts";
-import { MemoryStore } from "./memory.ts";
+import { DEFAULT_CONFIG, approvalDecision, type ChalinConfig } from "./config.ts";
+import type { MemoryStoreLike } from "./memory.ts";
+import { createConfiguredMemoryStore } from "./memory-provider.ts";
 import { MockWorkerRunner, SdkWorkerRunner, type WorkerRunner, type WorkerRunnerContext } from "./runner.ts";
 import type { AgentDefinition, AgentStage, AgentStep, AgentThinkingLevel, ApprovalDecision, MemoryRecord, RouteDecision, RoutePlan, RunState } from "./schemas.ts";
 
@@ -9,7 +10,7 @@ export interface ChalinKernelOptions {
   cwd?: string;
   config?: ChalinConfig;
   catalog?: AgentCatalog;
-  memory?: MemoryStore;
+  memory?: MemoryStoreLike;
   artifacts?: ArtifactStore;
   runner?: WorkerRunner;
   sdkRunner?: WorkerRunner;
@@ -29,7 +30,7 @@ export class ChalinKernel {
   private readonly cwd: string;
   private readonly config: ChalinConfig;
   private readonly catalog: AgentCatalog;
-  private readonly memory: MemoryStore;
+  private readonly memory: MemoryStoreLike;
   private readonly artifacts: ArtifactStore;
   private readonly runner: WorkerRunner;
   private readonly sdkRunner: WorkerRunner;
@@ -38,14 +39,9 @@ export class ChalinKernel {
 
   constructor(options?: ChalinKernelOptions) {
     this.cwd = options?.cwd ?? process.cwd();
-    this.config = options?.config ?? {
-      enabled: true,
-      autonomy: "balanced",
-      safety: { approvalRiskThreshold: "medium", recursionGuard: true, singleWriterGuard: true, mutationExpectationGuard: true, blockCritical: true },
-      agents: { modelOverrides: {}, thinkingOverrides: {}, modelPersistenceDefaults: { "built-in": "user", user: "user", project: "project" } },
-    };
+    this.config = options?.config ?? DEFAULT_CONFIG;
     this.catalog = options?.catalog ?? AgentCatalog.load({ cwd: this.cwd });
-    this.memory = options?.memory ?? new MemoryStore({ cwd: this.cwd });
+    this.memory = options?.memory ?? createConfiguredMemoryStore({ cwd: this.cwd }, this.config);
     this.artifacts = options?.artifacts ?? new ArtifactStore({ cwd: this.cwd });
     this.runner = options?.runner ?? new MockWorkerRunner();
     this.sdkRunner = options?.sdkRunner ?? new SdkWorkerRunner();