saeeol 1.0.9 → 1.1.1

package/src/cli/cmd/tui/routes/local-models.tsx

@@ -0,0 +1,151 @@
+/** TUI route — Local model management page */
+
+import { createSignal, createEffect, For, Show } from "solid-js"
+import type { BackendStatus, ModelInstance } from "@/provider/local/types"
+
+function fmt(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`
+  if (bytes < 1048576) return `${(bytes / 1024).toFixed(1)}KB`
+  if (bytes < 1073741824) return `${(bytes / 1048576).toFixed(1)}MB`
+  return `${(bytes / 1073741824).toFixed(1)}GB`
+}
+
+export function LocalModels() {
+  const [tab, setTab] = createSignal<0 | 1 | 2 | 3>(0)
+  const [backends, setBackends] = createSignal<BackendStatus[]>([])
+  const [instances, setInstances] = createSignal<ModelInstance[]>([])
+  const [installed, setInstalled] = createSignal<Array<{ repo: string; filename: string; path: string; sizeBytes: number }>>([])
+  const [gpu, setGpu] = createSignal<any>(null)
+  const [hubQuery, setHubQuery] = createSignal("")
+  const [hubResults, setHubResults] = createSignal<any[]>([])
+  const [loading, setLoading] = createSignal(false)
+
+  createEffect(() => { refresh() })
+
+  async function refresh() {
+    setLoading(true)
+    try {
+      const [g, b, m, i] = await Promise.all([
+        fetch("/local/gpu").then((r) => r.json()).catch(() => null),
+        fetch("/local/backends").then((r) => r.json()).catch(() => []),
+        fetch("/local/models").then((r) => r.json()).catch(() => []),
+        fetch("/local/instances").then((r) => r.json()).catch(() => []),
+      ])
+      setGpu(g); setBackends(b); setInstalled(m); setInstances(i)
+    } finally { setLoading(false) }
+  }
+
+  async function searchHub() {
+    const q = hubQuery(); if (!q) return
+    const res = await fetch(`/local/hub/search?q=${encodeURIComponent(q)}`)
+    setHubResults(await res.json())
+  }
+
+  async function loadModel(repo: string, filename: string) {
+    await fetch("/local/instances/load", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ repo, filename }) })
+    await refresh()
+  }
+
+  async function unloadModel(instanceId: string) {
+    await fetch("/local/instances/unload", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ instanceId }) })
+    await refresh()
+  }
+
+  const tabLabels = ["Backends", "Models", "HuggingFace", "RAG"]
+
+  return (
+    <box flexDirection="column" width="100%" height="100%" paddingTop={1} paddingBottom={1} paddingLeft={2} paddingRight={2}>
+      {/* Header */}
+      <box flexDirection="row">
+        <text fg="cyan">{"Local Models"}</text>
+        <text>{"  "}</text>
+        <Show when={gpu()} fallback={<text>{"No GPU info"}</text>}>
+          <text>{gpu().cudaAvailable ? `GPU: ${gpu().gpus.length}x | VRAM: ${gpu().availableVRAMMB}MB free` : "No CUDA GPU"}</text>
+        </Show>
+      </box>
+
+      {/* Tabs */}
+      <box flexDirection="row" paddingTop={1} paddingBottom={1}>
+        <For each={tabLabels}>
+          {(label, i) => (
+            <box paddingRight={3}>
+              <text fg={tab() === i() ? "green" : "white"}>{tab() === i() ? `[${label}]` : ` ${label} `}</text>
+            </box>
+          )}
+        </For>
+      </box>
+
+      {/* Tab: Backends */}
+      <Show when={tab() === 0}>
+        <text fg="white">{"Detected Backends"}</text>
+        <box paddingTop={1} />
+        <For each={backends()}>
+          {(b) => (
+            <box flexDirection="row" paddingBottom={1}>
+              <text fg={b.available ? "green" : "red"}>{b.available ? "● " : "○ "}</text>
+              <text>{b.type + "  "}</text>
+              <text>{b.endpoint}</text>
+            </box>
+          )}
+        </For>
+      </Show>
+
+      {/* Tab: Models */}
+      <Show when={tab() === 1}>
+        <text fg="white">{"Installed Models"}</text>
+        <box paddingTop={1} />
+        <For each={installed()}>
+          {(m) => (
+            <box flexDirection="row" paddingBottom={1}>
+              <text>{m.repo + "/" + m.filename + "  "}</text>
+              <text>{fmt(m.sizeBytes) + "  "}</text>
+              <text fg="green">{"[Load]"}</text>
+            </box>
+          )}
+        </For>
+
+        <Show when={instances().length > 0}>
+          <box paddingTop={1} />
+          <text fg="white">{"Running Instances"}</text>
+          <box paddingTop={1} />
+          <For each={instances()}>
+            {(inst) => (
+              <box flexDirection="row" paddingBottom={1}>
+                <text fg={inst.status === "running" ? "green" : "yellow"}>{inst.status + " "}</text>
+                <text>{inst.artifact.repo + " "}</text>
+                <Show when={inst.endpoint}><text>{ "-> " + inst.endpoint + " "}</text></Show>
+                <text fg="red">{"[Stop]"}</text>
+              </box>
+            )}
+          </For>
+        </Show>
+      </Show>
+
+      {/* Tab: Hub Search */}
+      <Show when={tab() === 2}>
+        <text fg="white">{"Search HuggingFace Hub"}</text>
+        <box paddingTop={1} />
+        <For each={hubResults()}>
+          {(r) => (
+            <box flexDirection="column" paddingBottom={1}>
+              <text fg="cyan">{r.id}</text>
+              <text>{`DL: ${r.downloads} | Likes: ${r.likes}${r.pipelineTag ? " | " + r.pipelineTag : ""}`}</text>
+            </box>
+          )}
+        </For>
+      </Show>
+
+      {/* Tab: RAG */}
+      <Show when={tab() === 3}>
+        <text fg="white">{"RAG Assets"}</text>
+        <box paddingTop={1} />
+        <text>{"Embedding models, rerankers, and vector databases for RAG pipelines"}</text>
+      </Show>
+
+      {/* Loading indicator */}
+      <Show when={loading()}>
+        <text fg="yellow">{"Loading..."}</text>
+      </Show>
+    </box>
+  )
+}

package/src/cli/cmd/tui/routes/session/subagent-footer.tsx

@@ -40,7 +40,7 @@ export function SubagentFooter() {
       last.tokens.input + last.tokens.output + last.tokens.reasoning + last.tokens.cache.read + last.tokens.cache.write
     if (tokens <= 0) return
 
-    const model = sync.data.provider.find((item) => item.id === last.providerID)?.models[last.modelID]
+    const model = sync.data.provider.find((item) => item.id === last.providerID)?.models?.[last.modelID]
     const pct = model?.limit.context ? `${Math.round((tokens / model.limit.context) * 100)}%` : undefined
     const cost = msg.reduce((sum, item) => sum + (item.role === "assistant" ? item.cost : 0), 0)
 

package/src/cli/cmd/tui/util/model.ts

@@ -11,7 +11,7 @@ export function get(list: Provider[] | ReadonlyMap<string, Provider> | undefined
       : Array.isArray(list)
         ? list.find((item) => item.id === providerID)
         : undefined
-  return provider?.models[modelID]
+  return provider?.models?.[modelID]
 }
 
 export function name(

package/src/config/config-schema.ts

@@ -228,6 +228,50 @@ export const Info = Schema.Struct({
       }),
     }),
   ),
+  ltm: Schema.optional(
+    Schema.Struct({
+      enabled: Schema.optional(Schema.Boolean).annotate({
+        description: "Enable long-term memory with local embedding (default: false)",
+      }),
+      embedding_model: Schema.optional(Schema.String).annotate({
+        description: "Embedding model ID or 'auto' for VRAM-based selection (default: auto)",
+      }),
+      vector_store: Schema.optional(Schema.Literals(["filesystem", "qdrant", "chroma"])).annotate({
+        description: "Vector store backend (default: filesystem)",
+      }),
+      max_memories: Schema.optional(PositiveInt).annotate({
+        description: "Maximum number of memories to retain (default: 10000)",
+      }),
+      episodic: Schema.optional(
+        Schema.Struct({
+          enabled: Schema.optional(Schema.Boolean).annotate({ description: "Enable episodic (conversation) memory" }),
+          summary_interval: Schema.optional(PositiveInt).annotate({ description: "Summarize every N turns (default: 10)" }),
+          retain_days: Schema.optional(PositiveInt).annotate({ description: "Days to retain episodic memories (default: 90)" }),
+        }),
+      ),
+      semantic: Schema.optional(
+        Schema.Struct({
+          enabled: Schema.optional(Schema.Boolean).annotate({ description: "Enable semantic (code) memory" }),
+          index_on_file_change: Schema.optional(Schema.Boolean).annotate({ description: "Auto-index on file change (default: true)" }),
+        }),
+      ),
+      procedural: Schema.optional(
+        Schema.Struct({
+          enabled: Schema.optional(Schema.Boolean).annotate({ description: "Enable procedural (preference) memory" }),
+          track_preferences: Schema.optional(Schema.Boolean).annotate({ description: "Track coding style preferences (default: true)" }),
+        }),
+      ),
+      retrieval: Schema.optional(
+        Schema.Struct({
+          top_k: Schema.optional(PositiveInt).annotate({ description: "Number of memories to retrieve (default: 5)" }),
+          min_score: Schema.optional(Schema.Number).annotate({ description: "Minimum similarity score 0-1 (default: 0.7)" }),
+          max_tokens: Schema.optional(PositiveInt).annotate({ description: "Max tokens to inject into prompt (default: 2000)" }),
+        }),
+      ),
+    }),
+  ).annotate({
+    description: "Long-term memory configuration with local embedding model",
+  }),
 })
   .annotate({ identifier: "Config" })
   .pipe(

package/src/ltm/config.ts

@@ -0,0 +1,124 @@
+/** LTM — 하드웨어 자동 감지 + 결정론적 LLM 파라미터 계산 */
+
+import os from "os"
+import { Effect } from "effect"
+import * as Log from "@saeeol/core/util/log"
+import { Global } from "@saeeol/core/global"
+import * as GPU from "@/provider/local/gpu"
+import * as RAG from "@/provider/local/rag"
+import type { HardwareProfile, LLMBakeParams, LTMConfig } from "./types"
+
+const log = Log.create({ service: "ltm/config" })
+
+// ── 기본 LTM 설정 ──
+
+export const DEFAULT_LTM_CONFIG: LTMConfig = {
+  enabled: false,
+  embeddingModel: "auto",
+  vectorStore: "filesystem",
+  maxMemories: 10000,
+  episodic: { enabled: true, summaryInterval: 10, retainDays: 90 },
+  semantic: { enabled: true, indexOnFileChange: true },
+  procedural: { enabled: true, trackPreferences: true },
+  retrieval: { topK: 5, minScore: 0.7, maxTokens: 2000 },
+}
+
+// ── 하드웨어 프로파일링 ──
+
+/** 시스템 하드웨어 정보 수집 */
+export async function profileHardware(): Promise<HardwareProfile> {
+  const gpu = await Effect.runPromise(GPU.profile)
+  const totalRAMMB = Math.round(os.totalmem() / (1024 * 1024))
+  const cpuCores = os.cpus().length
+
+  return {
+    gpuCount: gpu.gpus.length,
+    totalVRAMMB: gpu.totalVRAMMB,
+    availableVRAMMB: gpu.availableVRAMMB,
+    totalRAMMB,
+    cpuCores,
+    cudaAvailable: gpu.cudaAvailable,
+  }
+}
+
+/** 하드웨어 해시 (변경 감지용) */
+export function hardwareHash(hw: HardwareProfile): string {
+  const raw = `${hw.gpuCount}|${hw.totalVRAMMB}|${hw.totalRAMMB}|${hw.cpuCores}|${hw.cudaAvailable}`
+  let h = 0
+  for (let i = 0; i < raw.length; i++) {
+    h = ((h << 5) - h + raw.charCodeAt(i)) | 0
+  }
+  return h.toString(36)
+}
+
+// ── 임베딩 모델 선택 ──
+
+/** VRAM 기반 임베딩 모델 자동 선택 */
+export function selectEmbeddingModel(hw: HardwareProfile) {
+  const vram = hw.availableVRAMMB
+  // 한국어 지원 모델 우선
+  if (vram >= 3000 || hw.totalRAMMB >= 16000) return RAG.EMBEDDING_MODELS[3] // bge-m3, 1024d, 2.2GB
+  if (vram >= 1500 || hw.totalRAMMB >= 8000) return RAG.EMBEDDING_MODELS[4] // nomic-embed, 768d, 550MB
+  if (vram >= 500) return RAG.EMBEDDING_MODELS[0] // bge-small-en, 384d, 130MB
+  return RAG.EMBEDDING_MODELS[5] // all-minilm-l6, 384d, 80MB
+}
+
+// ── Bake (결정론적 파라미터 계산) ──
+
+/**
+ * 하드웨어 기반 LLM 파라미터를 계산하고 파일에 저장.
+ * 한 번 계산되면 하드웨어가 바뀌지 않는 한 동일한 값 유지.
+ */
+export async function bake(hw: HardwareProfile): Promise<LLMBakeParams> {
+  const existing = await readBake()
+  const hash = hardwareHash(hw)
+
+  // 해시가 같으면 기존 파라미터 재사용 (결정론적)
+  if (existing && existing.hardwareHash === hash) {
+    log.info("bake: hardware unchanged, reusing existing params", { hash })
+    return existing
+  }
+
+  const model = selectEmbeddingModel(hw)
+  const params: LLMBakeParams = {
+    embeddingModel: model.id,
+    embeddingDimensions: model.dimensions,
+    embeddingVRAMMB: Math.ceil(model.sizeBytes / (1024 * 1024)),
+    contextLength: hw.cudaAvailable ? 8192 : 4096,
+    batchSize: hw.cudaAvailable ? 64 : 16,
+    numThread: Math.max(1, Math.floor(hw.cpuCores * 0.75)),
+    numGPU: hw.cudaAvailable ? -1 : 0,
+    hardwareHash: hash,
+  }
+
+  await writeBake(params)
+  log.info("bake: computed new params", { hash, model: model.id })
+  return params
+}
+
+// ── 영속화 ──
+
+import path from "path"
+import { mkdir, readFile, writeFile } from "fs/promises"
+
+function bakeDir(): string {
+  return path.join(Global.Path.data, "ltm")
+}
+
+function bakePath(): string {
+  return path.join(bakeDir(), "bake.json")
+}
+
+async function readBake(): Promise<LLMBakeParams | undefined> {
+  try {
+    const raw = await readFile(bakePath(), "utf-8")
+    return JSON.parse(raw) as LLMBakeParams
+  } catch {
+    return undefined
+  }
+}
+
+async function writeBake(params: LLMBakeParams): Promise<void> {
+  await mkdir(bakeDir(), { recursive: true })
+  await writeFile(bakePath(), JSON.stringify(params, null, 2))
+}

package/src/ltm/events.ts

@@ -0,0 +1,50 @@
+/** LTM — BusEvent 정의 */
+
+import { Schema } from "effect"
+import * as BusEvent from "@/bus/bus-event"
+
+export const LTMEvent = {
+  MemoryStored: BusEvent.define(
+    "ltm.memory.stored",
+    Schema.Struct({
+      id: Schema.String,
+      type: Schema.String,
+      source: Schema.String,
+    }),
+  ),
+
+  MemoryPruned: BusEvent.define(
+    "ltm.memory.pruned",
+    Schema.Struct({
+      count: Schema.Number,
+      type: Schema.optional(Schema.String),
+    }),
+  ),
+
+  IndexingProgress: BusEvent.define(
+    "ltm.indexing.progress",
+    Schema.Struct({
+      processed: Schema.Number,
+      total: Schema.Number,
+      type: Schema.String,
+    }),
+  ),
+
+  EmbedderStatusChanged: BusEvent.define(
+    "ltm.embedder.status",
+    Schema.Struct({
+      status: Schema.String,
+      model: Schema.optional(Schema.String),
+    }),
+  ),
+
+  HardwareProfiled: BusEvent.define(
+    "ltm.hardware.profiled",
+    Schema.Struct({
+      gpuCount: Schema.Number,
+      totalVRAMMB: Schema.Number,
+      totalRAMMB: Schema.Number,
+      cpuCores: Schema.Number,
+    }),
+  ),
+}

package/src/ltm/index.ts

@@ -0,0 +1,12 @@
+/** LTM — 장기 기억 공개 API */
+
+export * from "./types"
+export * as Config from "./config"
+export * as Store from "./store"
+export * as Pipeline from "./pipeline"
+export * as Retrieval from "./retrieval"
+export * as Scheduler from "./scheduler"
+export * as Episodic from "./memory/episodic"
+export * as Semantic from "./memory/semantic"
+export * as Procedural from "./memory/procedural"
+export { LTMEvent } from "./events"

package/src/ltm/memory/episodic.ts

@@ -0,0 +1,83 @@
+/** LTM episodic memory — conversation summaries (English, LLM-to-LLM) */
+
+import * as Log from "@saeeol/core/util/log"
+import * as Embedder from "@/provider/local/embedder"
+import type { Memory } from "@/ltm/types"
+
+const log = Log.create({ service: "ltm/memory/episodic" })
+
+/** Create an episodic memory from a conversation exchange */
+export async function fromConversation(
+  sessionID: string,
+  projectID: string | undefined,
+  userMsg: string,
+  assistantMsg: string,
+): Promise<Memory | undefined> {
+  if (assistantMsg.length < 50) return undefined
+
+  const summary = summarize(userMsg, assistantMsg)
+  if (!summary) return undefined
+
+  try {
+    const vector = await Embedder.embedOne(summary)
+    return {
+      id: `epi:${sessionID}:${Date.now()}`,
+      type: "episodic",
+      content: assistantMsg.slice(0, 500),
+      summary,
+      vector,
+      metadata: {
+        source: `session:${sessionID}`,
+        timestamp: Date.now(),
+        projectID,
+        sessionID,
+        tags: extractTags(userMsg + " " + assistantMsg),
+      },
+    }
+  } catch (e) {
+    log.error("failed to create episodic memory", { error: e })
+    return undefined
+  }
+}
+
+/** Build a rule-based summary (no LLM call) */
+function summarize(user: string, assistant: string): string {
+  const userBrief = user.slice(0, 120).replace(/\n/g, " ").trim()
+  const assistantBrief = assistant.slice(0, 200).replace(/\n/g, " ").trim()
+  return `user asked: ${userBrief}\nassistant did: ${assistantBrief}`
+}
+
+/** Extract topic tags from message content */
+function extractTags(msg: string): string[] {
+  const tags: string[] = []
+  const lower = msg.toLowerCase()
+
+  const patterns: Array<{ keyword: string; tag: string }> = [
+    { keyword: "bug", tag: "bug" },
+    { keyword: "fix", tag: "fix" },
+    { keyword: "refactor", tag: "refactor" },
+    { keyword: "test", tag: "test" },
+    { keyword: "config", tag: "config" },
+    { keyword: "api", tag: "api" },
+    { keyword: "auth", tag: "auth" },
+    { keyword: "deploy", tag: "deploy" },
+    { keyword: "error", tag: "error" },
+    { keyword: "crash", tag: "crash" },
+    { keyword: "performance", tag: "perf" },
+    { keyword: "security", tag: "security" },
+    { keyword: "database", tag: "database" },
+    { keyword: "migration", tag: "migration" },
+    { keyword: "feature", tag: "feature" },
+  ]
+
+  for (const { keyword, tag } of patterns) {
+    if (lower.includes(keyword) && !tags.includes(tag)) tags.push(tag)
+  }
+
+  return tags
+}
+
+/** Check if summarization should trigger at this turn count */
+export function shouldSummarize(turnCount: number, interval: number): boolean {
+  return turnCount > 0 && turnCount % interval === 0
+}

package/src/ltm/memory/procedural.ts

@@ -0,0 +1,102 @@
+/** LTM procedural memory — user coding preferences and patterns (English, LLM-to-LLM) */
+
+import * as Log from "@saeeol/core/util/log"
+import * as Embedder from "@/provider/local/embedder"
+import type { Memory } from "@/ltm/types"
+
+const log = Log.create({ service: "ltm/memory/procedural" })
+
+/** A detected coding style signal */
+interface StyleSignal {
+  language: string
+  pattern: string
+  evidence: string
+}
+
+/** Extract coding style signals from a file edit */
+export function extractStyleSignals(
+  filePath: string,
+  content: string,
+): StyleSignal[] {
+  const signals: StyleSignal[] = []
+  const ext = filePath.split(".").pop() ?? ""
+
+  // Comment language
+  if (content.includes("//") && (ext === "ts" || ext === "js")) {
+    const hasKoreanComment = /[ㄱ-ㅎㅏ-ㅣ가-힣]/.test(content)
+    signals.push({
+      language: ext,
+      pattern: "comment-language",
+      evidence: hasKoreanComment ? "comments in Korean" : "comments in English",
+    })
+  }
+
+  // Indentation
+  if (content.includes("  ") && !content.includes("\t")) {
+    signals.push({ language: ext, pattern: "indent", evidence: "2-space indentation" })
+  } else if (content.includes("\t")) {
+    signals.push({ language: ext, pattern: "indent", evidence: "tab indentation" })
+  }
+
+  // Semicolons
+  if (ext === "ts" || ext === "js") {
+    const hasSemicolons = /;\s*\n/.test(content)
+    signals.push({
+      language: ext,
+      pattern: "semicolons",
+      evidence: hasSemicolons ? "uses semicolons" : "no semicolons",
+    })
+  }
+
+  // Quote style
+  const singleQuotes = (content.match(/'/g) ?? []).length
+  const doubleQuotes = (content.match(/"/g) ?? []).length
+  if (singleQuotes > doubleQuotes * 2) {
+    signals.push({ language: ext, pattern: "quotes", evidence: "prefers single quotes" })
+  } else if (doubleQuotes > singleQuotes * 2) {
+    signals.push({ language: ext, pattern: "quotes", evidence: "prefers double quotes" })
+  }
+
+  // Naming: camelCase vs snake_case
+  const camelCase = (content.match(/[a-z][A-Z]/g) ?? []).length
+  const snakeCase = (content.match(/_[a-z]/g) ?? []).length
+  if (camelCase > snakeCase * 3) {
+    signals.push({ language: ext, pattern: "naming", evidence: "camelCase naming" })
+  } else if (snakeCase > camelCase * 3) {
+    signals.push({ language: ext, pattern: "naming", evidence: "snake_case naming" })
+  }
+
+  return signals
+}
+
+/** Convert style signals into procedural memories */
+export async function fromStyleSignals(
+  projectID: string | undefined,
+  signals: StyleSignal[],
+): Promise<Memory[]> {
+  const memories: Memory[] = []
+
+  for (const signal of signals) {
+    const summary = `user coding style: ${signal.language} ${signal.pattern} = ${signal.evidence}`
+    try {
+      const vector = await Embedder.embedOne(summary)
+      memories.push({
+        id: `proc:style:${signal.language}:${signal.pattern}`,
+        type: "procedural",
+        content: signal.evidence,
+        summary,
+        vector,
+        metadata: {
+          source: `style:${signal.language}`,
+          timestamp: Date.now(),
+          projectID,
+          tags: ["style", signal.language, signal.pattern],
+        },
+      })
+    } catch (e) {
+      log.error("failed to create procedural memory", { error: e, pattern: signal.pattern })
+    }
+  }
+
+  return memories
+}

package/src/ltm/memory/semantic.ts

@@ -0,0 +1,80 @@
+/** LTM semantic memory — code and project knowledge (English, LLM-to-LLM) */
+
+import * as Log from "@saeeol/core/util/log"
+import * as Embedder from "@/provider/local/embedder"
+import type { Memory } from "@/ltm/types"
+
+const log = Log.create({ service: "ltm/memory/semantic" })
+
+/** Create a semantic memory from a code chunk */
+export async function fromCodeChunk(
+  projectID: string,
+  filePath: string,
+  chunk: string,
+  startLine: number,
+  endLine: number,
+): Promise<Memory | undefined> {
+  if (chunk.length < 20) return undefined
+
+  const summary = codeSummary(filePath, chunk, startLine, endLine)
+
+  try {
+    const vector = await Embedder.embedOne(summary)
+    return {
+      id: `sem:${projectID}:${filePath}:${startLine}-${endLine}`,
+      type: "semantic",
+      content: chunk.slice(0, 500),
+      summary,
+      vector,
+      metadata: {
+        source: `file:${filePath}`,
+        timestamp: Date.now(),
+        projectID,
+        tags: [pathExtension(filePath), "code"],
+      },
+    }
+  } catch (e) {
+    log.error("failed to create semantic memory", { error: e, filePath })
+    return undefined
+  }
+}
+
+/** Create a semantic memory from project structure overview */
+export async function fromProjectStructure(
+  projectID: string,
+  structure: string,
+): Promise<Memory | undefined> {
+  const summary = `project structure: ${structure.slice(0, 300)}`
+
+  try {
+    const vector = await Embedder.embedOne(summary)
+    return {
+      id: `sem:${projectID}:structure`,
+      type: "semantic",
+      content: structure.slice(0, 500),
+      summary,
+      vector,
+      metadata: {
+        source: `project:${projectID}`,
+        timestamp: Date.now(),
+        projectID,
+        tags: ["structure"],
+      },
+    }
+  } catch (e) {
+    log.error("failed to create project structure memory", { error: e })
+    return undefined
+  }
+}
+
+/** Build a code chunk summary for embedding */
+function codeSummary(filePath: string, chunk: string, start: number, end: number): string {
+  const ext = pathExtension(filePath)
+  const preview = chunk.slice(0, 150).replace(/\n/g, " ").trim()
+  return `${filePath}:${start}-${end} (${ext}) ${preview}`
+}
+
+function pathExtension(filePath: string): string {
+  const parts = filePath.split(".")
+  return parts.length > 1 ? parts[parts.length - 1]! : "unknown"
+}