pi-obsidian-memory 0.0.1 → 0.1.0

package/src/pi/memory-add/constants.ts

@@ -0,0 +1,13 @@
+export const MEMORY_ADD_TOOL_NAME = "memory_add"
+
+export const MEMORY_ADD_TOOL_LABEL = "Memory add"
+
+export const MEMORY_ADD_TOOL_DESCRIPTION = "Use only when the user explicitly asks to remember something."
+
+export const SAME_POINT_GUIDANCE =
+  "If it is the same point, leave the existing note unchanged or, only if the user asked to change it, read it with memory_get and change it with memory_update; otherwise choose a statement that says what is new."
+
+export const NO_PROJECT_GUIDANCE =
+  "Ask the user whether to run /memory-init in this folder to register the project or to save it with global scope."
+
+export const SETUP_GUIDANCE = "Memory is off: ask the user to run /memory-setup."

package/src/pi/memory-add/index.ts

@@ -0,0 +1,5 @@
+export * from "./constants.ts"
+export * from "./memory-add.ts"
+export * from "./respond.ts"
+export * from "./schemas.ts"
+export * from "./types.ts"

package/src/pi/memory-add/memory-add.ts

@@ -0,0 +1,31 @@
+import type { MemoryPaths } from "#src/pi/context"
+import { type MemorySessionKeeper, noSessionResponse } from "#src/pi/memory-session"
+import { addMemory, type MemoryOperationContext } from "#src/usecases"
+import { MEMORY_ADD_TOOL_DESCRIPTION, MEMORY_ADD_TOOL_LABEL, MEMORY_ADD_TOOL_NAME } from "./constants.ts"
+import { respondTo } from "./respond.ts"
+import { MemoryAddParamsSchema } from "./schemas.ts"
+import type { MemoryAddParams, MemoryAddResponse, MemoryAddTool } from "./types.ts"
+
+export function memoryAddTool(paths: MemoryPaths, sessions: MemorySessionKeeper): MemoryAddTool {
+  return {
+    name: MEMORY_ADD_TOOL_NAME,
+    label: MEMORY_ADD_TOOL_LABEL,
+    description: MEMORY_ADD_TOOL_DESCRIPTION,
+    parameters: MemoryAddParamsSchema,
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      const context = sessions.currentOperation(ctx.cwd, paths, signal)
+      if (!context) return noSessionResponse()
+      return runMemoryAdd(params, context)
+    },
+  }
+}
+
+export async function runMemoryAdd(
+  params: MemoryAddParams,
+  context: MemoryOperationContext,
+): Promise<MemoryAddResponse> {
+  const { scope, folder, statement, type, body, dontForget } = params
+  const result = await addMemory({ scope, folder, draft: { statement, type, body, dontForget } }, context)
+
+  return respondTo(result)
+}

package/src/pi/memory-add/respond.ts

@@ -0,0 +1,55 @@
+import type { AddedMemory, AddMemoryResult, ExistingMemoryRefusal } from "#src/usecases"
+import { NO_PROJECT_GUIDANCE, SAME_POINT_GUIDANCE, SETUP_GUIDANCE } from "./constants.ts"
+import type { AddedDetails, MemoryAddResponse } from "./types.ts"
+
+export function respondTo(result: AddMemoryResult): MemoryAddResponse {
+  if (result.succeeded) {
+    return reply(describeSaved(result.output), false, { vault: result.output.scope, path: result.output.notePath })
+  }
+
+  switch (result.reason) {
+    case "exists":
+      if ("existing" in result) {
+        return reply(describeExisting(result), true)
+      }
+      return reply(result.problems.join("\n"), true)
+    case "invalid":
+      return reply(
+        ["Not saved. Fix and call again:", ...result.problems.map((problem) => `- ${problem}`)].join("\n"),
+        true,
+      )
+    case "no-project":
+      return reply([...result.problems, `Config: ${result.configPath}`, NO_PROJECT_GUIDANCE].join("\n"), true)
+    case "not-configured":
+    case "invalid-config":
+      return reply([...result.problems, SETUP_GUIDANCE].join("\n"), true)
+    case "unreadable":
+      return reply([...result.problems, `Config: ${result.configPath}`].join("\n"), true)
+    case "not-directory":
+    case "not-readable":
+    case "not-writable":
+    case "outside-vault":
+    case "vault-missing":
+    case "not-found":
+    case "cancelled":
+    case "stale-session":
+    case "admission-refused":
+      return reply(result.problems.join("\n"), true)
+  }
+}
+
+function describeSaved(memory: AddedMemory): string {
+  const warnings = memory.maintenanceProblems.map((problem) => `Maintenance warning: ${problem}`)
+  return [`Saved in ${memory.vaultName}: ${memory.notePath}`, ...warnings].join("\n")
+}
+
+function describeExisting(refusal: ExistingMemoryRefusal): string {
+  const { note } = refusal.existing
+  const problems = refusal.problems.map((problem) => `Not saved: ${problem}.`)
+
+  return [...problems, "", `Current note (${note.frontmatter.type}):`, note.body, "", SAME_POINT_GUIDANCE].join("\n")
+}
+
+function reply(text: string, isError: boolean, details?: AddedDetails): MemoryAddResponse {
+  return { content: [{ type: "text", text }], details, isError }
+}

package/src/pi/memory-add/schemas.ts

@@ -0,0 +1,29 @@
+import Type from "typebox"
+
+import { AddMemoryRequestSchema } from "#src/usecases"
+
+export const MemoryAddParamsSchema = Type.Object(
+  {
+    scope: Type.With(AddMemoryRequestSchema.properties.scope, {
+      description: "global: about the user. project: about this project. If unsure, ask the user before calling.",
+    }),
+    folder: Type.With(AddMemoryRequestSchema.properties.folder, {
+      description:
+        "Subject folder in English, from general to specific (typescript/testing). Reuse a folder that already exists.",
+    }),
+    statement: Type.With(AddMemoryRequestSchema.properties.draft.properties.statement, {
+      description:
+        "The note name, in English: one short statement saying exactly what the note says (Use pnpm, never npm).",
+    }),
+    type: Type.With(AddMemoryRequestSchema.properties.draft.properties.type, {
+      description: "The kind of memory.",
+    }),
+    body: Type.With(AddMemoryRequestSchema.properties.draft.properties.body, {
+      description: "The full detail, in English. Never empty.",
+    }),
+    dontForget: Type.With(AddMemoryRequestSchema.properties.draft.properties.dontForget, {
+      description: "true only when it must be loaded in every session.",
+    }),
+  },
+  { additionalProperties: false },
+)

package/src/pi/memory-add/types.ts

@@ -0,0 +1,15 @@
+import type { AgentToolResult, ToolDefinition } from "@earendil-works/pi-coding-agent"
+import type { Static } from "typebox"
+
+import type { MemoryAddParamsSchema } from "./schemas.ts"
+
+export type MemoryAddParams = Static<typeof MemoryAddParamsSchema>
+
+export interface AddedDetails {
+  vault: "global" | "project"
+  path: string
+}
+
+export type MemoryAddTool = ToolDefinition<typeof MemoryAddParamsSchema, AddedDetails | undefined>
+
+export type MemoryAddResponse = AgentToolResult<AddedDetails | undefined>

package/src/pi/memory-archive/constants.ts

@@ -0,0 +1,8 @@
+export const MEMORY_ARCHIVE_TOOL_NAME = "memory_archive"
+
+export const MEMORY_ARCHIVE_TOOL_LABEL = "Memory archive"
+
+export const MEMORY_ARCHIVE_TOOL_DESCRIPTION =
+  "Use only when the user explicitly asks to retire a memory with no successor. Read it with memory_get first."
+
+export const ARCHIVED_PREFIX = "Archived in"

package/src/pi/memory-archive/index.ts

@@ -0,0 +1,4 @@
+export * from "./constants.ts"
+export * from "./memory-archive.ts"
+export * from "./schemas.ts"
+export * from "./types.ts"

package/src/pi/memory-archive/memory-archive.ts

@@ -0,0 +1,29 @@
+import { type ChangeResponse, reportFailure, reportSuccess } from "#src/pi/change-report"
+import type { MemoryPaths } from "#src/pi/context"
+import { type MemorySessionKeeper, noSessionResponse } from "#src/pi/memory-session"
+import { archiveMemory } from "#src/usecases"
+import {
+  ARCHIVED_PREFIX,
+  MEMORY_ARCHIVE_TOOL_DESCRIPTION,
+  MEMORY_ARCHIVE_TOOL_LABEL,
+  MEMORY_ARCHIVE_TOOL_NAME,
+} from "./constants.ts"
+import { MemoryArchiveParamsSchema } from "./schemas.ts"
+import type { MemoryArchiveTool } from "./types.ts"
+
+export function memoryArchiveTool(paths: MemoryPaths, sessions: MemorySessionKeeper): MemoryArchiveTool {
+  return {
+    name: MEMORY_ARCHIVE_TOOL_NAME,
+    label: MEMORY_ARCHIVE_TOOL_LABEL,
+    description: MEMORY_ARCHIVE_TOOL_DESCRIPTION,
+    parameters: MemoryArchiveParamsSchema,
+    async execute(_toolCallId, params, signal, _onUpdate, ctx): Promise<ChangeResponse> {
+      const context = sessions.currentOperation(ctx.cwd, paths, signal)
+      if (!context) return noSessionResponse()
+      const result = await archiveMemory(params, context)
+      if (!result.succeeded) return reportFailure(result, params.path)
+      const { vault, archivedPath, maintenanceProblems } = result.output
+      return reportSuccess(`${ARCHIVED_PREFIX} ${vault}: ${archivedPath}`, maintenanceProblems)
+    },
+  }
+}

package/src/pi/memory-archive/schemas.ts

@@ -0,0 +1,15 @@
+import Type from "typebox"
+
+import { ArchiveMemoryRequestSchema } from "#src/usecases"
+
+export const MemoryArchiveParamsSchema = Type.Object(
+  {
+    vault: Type.With(ArchiveMemoryRequestSchema.properties.vault, {
+      description: "global: about the user. project: about this project. The vault the note was read from.",
+    }),
+    path: Type.With(ArchiveMemoryRequestSchema.properties.path, {
+      description: "The note's path, exactly as read with memory_get.",
+    }),
+  },
+  { additionalProperties: false },
+)

package/src/pi/memory-archive/types.ts

@@ -0,0 +1,8 @@
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent"
+import type { Static } from "typebox"
+
+import type { MemoryArchiveParamsSchema } from "./schemas.ts"
+
+export type MemoryArchiveParams = Static<typeof MemoryArchiveParamsSchema>
+
+export type MemoryArchiveTool = ToolDefinition<typeof MemoryArchiveParamsSchema, undefined>

package/src/pi/memory-block/block.ts

@@ -0,0 +1,75 @@
+import { STATUS_LOADING, withMemoryStatus } from "#src/pi/context"
+import { trackDontForget } from "#src/usecases"
+import { BLOCK_SEPARATOR, MEMORY_BLOCK_SECTION, RELEVANT_LOAD_ERROR_PREFIX } from "./constants.ts"
+import { loadNotices, renderLoadFailure, renderLoadNotice, renderMemoryBlock } from "./render.ts"
+import type { BeforeAgentStartHandler, BlockStart, DontForgetLoader } from "./types.ts"
+
+export class MemoryBlock {
+  #text: Promise<string | null> = Promise.resolve(null)
+  #load: DontForgetLoader
+
+  constructor(load: DontForgetLoader) {
+    this.#load = load
+  }
+
+  begin(start: BlockStart): void {
+    if (!start.configured) {
+      this.clear()
+      return
+    }
+    this.#text = withMemoryStatus(start.ctx, STATUS_LOADING, () => this.#loadBlock(start))
+  }
+
+  async #loadBlock(start: BlockStart): Promise<string | null> {
+    const dontForget = this.#load(start.context).then(
+      (result) => {
+        trackDontForget(start.loaded, result)
+        start.notify(loadNotices(result))
+        return renderMemoryBlock(result)
+      },
+      (error) => {
+        start.notify([renderLoadNotice(errorMessage(error))])
+        return renderLoadFailure(errorMessage(error))
+      },
+    )
+    const [block, extra] = await Promise.all([
+      dontForget,
+      start.relevant().catch((error) => this.#relevantFailed(start, error)),
+    ])
+    return joined(block, extra)
+  }
+
+  #relevantFailed(start: BlockStart, error: Error | string): null {
+    start.notify([`${RELEVANT_LOAD_ERROR_PREFIX} ${errorMessage(error)}`])
+    return null
+  }
+
+  async settled(): Promise<void> {
+    await this.#text.then(noop, noop)
+  }
+
+  clear(): void {
+    this.#text = Promise.resolve(null)
+  }
+
+  beforeAgentStart(): BeforeAgentStartHandler {
+    return async (event) => {
+      const text = await this.#text
+      if (typeof text === "string") event.systemPromptOptions.sections[MEMORY_BLOCK_SECTION] = text
+      return undefined
+    }
+  }
+}
+
+function noop(): void {}
+
+function joined(block: string | null, extra: string | null): string | null {
+  if (typeof block !== "string") return null
+  if (typeof extra !== "string") return block
+  return [block, extra].join(BLOCK_SEPARATOR)
+}
+
+function errorMessage(error: Error | string): string {
+  if (error instanceof Error) return error.message
+  return String(error)
+}

package/src/pi/memory-block/constants.ts

@@ -0,0 +1,24 @@
+export const MEMORY_BLOCK_SECTION = "obsidian_memory"
+
+export const BLOCK_INTRO =
+  "This is only part of your long-term memory, kept in Obsidian vaults. Use memory_search to find more, and memory_get to read a note in full or a folder's index."
+
+export const DONT_FORGET_HEADING = "Don't forget notes:"
+
+export const NO_DONT_FORGET = "No note is marked Don't forget."
+
+export const BLOCK_NEEDS_FIXING_HEADING = "Needs fixing:"
+
+export const NOTE_HEADING_PREFIX = "### "
+
+export const BLOCK_FIELD_SEPARATOR = " · "
+
+export const LOAD_FAILURE_PREFIX = "Could not load the"
+
+export const LOAD_FAILURE_SUFFIX = "vault:"
+
+export const LOAD_ERROR_PREFIX = "Could not load Don't forget notes:"
+
+export const RELEVANT_LOAD_ERROR_PREFIX = "Could not load relevant notes:"
+
+export const BLOCK_SEPARATOR = "\n\n"

package/src/pi/memory-block/index.ts

@@ -0,0 +1,4 @@
+export * from "./block.ts"
+export * from "./constants.ts"
+export * from "./render.ts"
+export * from "./types.ts"

package/src/pi/memory-block/render.ts

@@ -0,0 +1,54 @@
+import type { DontForgetVault, LoadDontForgetResult, LoadedDontForgetNote } from "#src/usecases"
+import {
+  BLOCK_FIELD_SEPARATOR,
+  BLOCK_INTRO,
+  BLOCK_NEEDS_FIXING_HEADING,
+  BLOCK_SEPARATOR,
+  DONT_FORGET_HEADING,
+  LOAD_ERROR_PREFIX,
+  LOAD_FAILURE_PREFIX,
+  LOAD_FAILURE_SUFFIX,
+  NO_DONT_FORGET,
+  NOTE_HEADING_PREFIX,
+} from "./constants.ts"
+
+export function renderMemoryBlock(result: LoadDontForgetResult): string | null {
+  if (!result.succeeded) {
+    if (result.reason === "not-configured") return null
+    return renderLoadFailure(result.problems.join("; "))
+  }
+  const notes = result.output.vaults.flatMap((vault) => vault.notes)
+  const parts = [BLOCK_INTRO]
+  if (notes.length === 0) parts.push(NO_DONT_FORGET)
+  else parts.push(DONT_FORGET_HEADING, ...notes.map(renderNote))
+  for (const vault of result.output.vaults) parts.push(...renderFailure(vault))
+  return parts.join(BLOCK_SEPARATOR)
+}
+
+function renderNote(note: LoadedDontForgetNote): string {
+  const heading = `${NOTE_HEADING_PREFIX}${[note.vault, note.path, note.type].join(BLOCK_FIELD_SEPARATOR)}`
+  const lines = [heading, note.body]
+  if (note.problems.length > 0)
+    lines.push(BLOCK_NEEDS_FIXING_HEADING, ...note.problems.map((problem) => `- ${problem}`))
+  return lines.join("\n")
+}
+
+function renderFailure(vault: DontForgetVault): string[] {
+  return vault.problems.map((problem) => `${LOAD_FAILURE_PREFIX} ${vault.vault} ${LOAD_FAILURE_SUFFIX} ${problem}`)
+}
+
+export function loadNotices(result: LoadDontForgetResult): string[] {
+  if (!result.succeeded) {
+    if (result.reason === "not-configured") return []
+    return [renderLoadNotice(result.problems.join("; "))]
+  }
+  return result.output.vaults.flatMap(renderFailure)
+}
+
+export function renderLoadNotice(message: string): string {
+  return `${LOAD_ERROR_PREFIX} ${message}`
+}
+
+export function renderLoadFailure(message: string): string {
+  return [BLOCK_INTRO, renderLoadNotice(message)].join(BLOCK_SEPARATOR)
+}

package/src/pi/memory-block/types.ts

@@ -0,0 +1,24 @@
+import type { BeforeAgentStartEvent, BeforeAgentStartEventResult } from "@earendil-works/pi-coding-agent"
+
+import type { MemoryPiContext } from "#src/pi/context"
+import type { LoadDontForgetResult, LoadedMemory, MemoryOperationContext } from "#src/usecases"
+
+export type BeforeAgentStartHandler = (
+  event: BeforeAgentStartEvent,
+  ctx: MemoryPiContext,
+) => Promise<BeforeAgentStartEventResult | undefined>
+
+export type RelevantLoader = () => Promise<string | null>
+
+export type BlockNotifier = (messages: string[]) => void
+
+export interface BlockStart {
+  ctx: MemoryPiContext
+  context: MemoryOperationContext
+  configured: boolean
+  loaded: LoadedMemory
+  relevant: RelevantLoader
+  notify: BlockNotifier
+}
+
+export type DontForgetLoader = (context: MemoryOperationContext) => Promise<LoadDontForgetResult>

package/src/pi/memory-doctor/constants.ts

@@ -0,0 +1,43 @@
+export const MEMORY_DOCTOR_COMMAND = "memory-doctor"
+
+export const MEMORY_DOCTOR_DESCRIPTION = "Check the memory for problems and offer to complete blank notes"
+
+export const DOCTOR_TITLE = "Memory doctor"
+
+export const DOCTOR_SETUP_HINT = "Run /memory-setup to create or repair the config."
+
+export const NO_PROBLEMS = "no problems found."
+
+export const COULD_NOT_CHECK = "could not be checked."
+
+export const DOCTOR_NO_PROJECT_VAULT = "No project vault is registered for this folder."
+
+export const DOCTOR_INVALID_HEADING = "Invalid notes:"
+
+export const DUPLICATES_HEADING = "Copied ids:"
+
+export const BLANK_HEADING = "Blank notes (no frontmatter):"
+
+export const TEMPORARIES_HEADING = "Leftover temporary files:"
+
+export const UNREADABLE_HEADING = "Files that could not be read:"
+
+export const CUTOFF_SOURCES = new Map<string, string>([
+  ["config", "config"],
+  ["typesafe", "TypeSafe starting value"],
+  ["missing", "missing"],
+])
+
+export const CUTOFFS_HINT = "set both cutoffs in /memory-setup, see docs/decision-thresholds.md"
+
+export const MODELS_HEADING = "Models:"
+
+export const COMPLETE_TYPE_TITLE = "Complete this blank note: which type is it?"
+
+export const COMPLETE_BODY_TITLE = "Body of the new note (written in English)"
+
+export const COMPLETE_CONFIRM_MESSAGE = "A new id and dates are added and the file is rewritten as a note."
+
+export const COMPLETED = "Completed"
+
+export const COMPLETE_SKIPPED = "Left unchanged:"

package/src/pi/memory-doctor/index.ts

@@ -0,0 +1,4 @@
+export * from "./constants.ts"
+export * from "./memory-doctor.ts"
+export * from "./report.ts"
+export * from "./types.ts"

package/src/pi/memory-doctor/memory-doctor.ts

@@ -0,0 +1,135 @@
+import type { MemoryCommand, MemoryPaths, MemoryPiContext } from "#src/pi/context"
+import type { MemorySessionKeeper } from "#src/pi/memory-session"
+import {
+  BLANK_NOTE_TYPES,
+  type BlankFile,
+  completeBlankMemory,
+  type DecisionProbe,
+  type DiagnosedMemory,
+  diagnoseMemory,
+  type EmbeddingProbe,
+  type MemoryOperationContext,
+  type VaultReport,
+} from "#src/usecases"
+import {
+  COMPLETE_BODY_TITLE,
+  COMPLETE_CONFIRM_MESSAGE,
+  COMPLETE_SKIPPED,
+  COMPLETE_TYPE_TITLE,
+  COMPLETED,
+  DOCTOR_SETUP_HINT,
+  MEMORY_DOCTOR_DESCRIPTION,
+} from "./constants.ts"
+import { renderDoctorReport } from "./report.ts"
+import type { BlankTarget, DoctorModelPort } from "./types.ts"
+
+export function memoryDoctorCommand(
+  paths: MemoryPaths,
+  sessions: MemorySessionKeeper,
+  modelCachePath: string,
+): MemoryCommand {
+  return {
+    description: MEMORY_DOCTOR_DESCRIPTION,
+    async handler(_args, ctx) {
+      if (!ctx.hasUI) return
+      const { registration } = sessions.registrationFlow(ctx, paths)
+      await runMemoryDoctor(ctx, registration, modelCachePath)
+    },
+  }
+}
+
+async function runMemoryDoctor(
+  ctx: MemoryPiContext,
+  context: MemoryOperationContext,
+  modelCachePath: string,
+): Promise<void> {
+  const port: DoctorModelPort = {
+    find: (provider, id) => ctx.modelRegistry.find(provider, id),
+    configured: (model) => ctx.modelRegistry.hasConfiguredAuth(model),
+    auth: (model) => ctx.modelRegistry.getApiKeyAndHeaders(model),
+  }
+  const diagnosed = await diagnoseMemory(
+    { port, embeddings: embeddingProbeOf(ctx, modelCachePath), decision: decisionProbeOf(ctx) },
+    context,
+  )
+  if (!diagnosed.succeeded) {
+    return ctx.ui.notify([...diagnosed.problems, DOCTOR_SETUP_HINT].join("\n"), "error")
+  }
+  ctx.ui.notify(renderDoctorReport(diagnosed.output), levelOf(diagnosed.output))
+  for (const target of blankTargets(diagnosed.output)) await offerCompletion(ctx, context, target)
+}
+
+function levelOf(diagnosed: DiagnosedMemory): "info" | "warning" {
+  for (const report of diagnosed.vaults) {
+    if ("problems" in report) return "warning"
+    const { diagnosis } = report
+    const found = [
+      diagnosis.invalid,
+      diagnosis.duplicateIds,
+      diagnosis.blank,
+      diagnosis.temporaries,
+      diagnosis.crowdedFolders,
+    ]
+    if (found.some((items) => items.length > 0) || report.unreadable.length > 0) return "warning"
+  }
+  if (diagnosed.models.some((report) => report.check.status !== "ok")) return "warning"
+  if (diagnosed.embeddings.status !== "ready") return "warning"
+  if ("problem" in diagnosed.decision) return "warning"
+  if (diagnosed.cutoffs.gate.source === "missing" || diagnosed.cutoffs.relevance.source === "missing") return "warning"
+  return "info"
+}
+
+function blankTargets(diagnosed: DiagnosedMemory): BlankTarget[] {
+  const reports = diagnosed.vaults.filter((report): report is VaultReport => "blanks" in report)
+  return reports.flatMap((report) => report.blanks.map((blank: BlankFile) => ({ vault: report.vault, blank })))
+}
+
+async function offerCompletion(
+  ctx: MemoryPiContext,
+  context: MemoryOperationContext,
+  target: BlankTarget,
+): Promise<void> {
+  const { vault, blank } = target
+  const label = `${vault}/${blank.path}`
+  const type = await ctx.ui.select(`${COMPLETE_TYPE_TITLE} (${label})`, [...BLANK_NOTE_TYPES])
+  if (!isNoteType(type)) return ctx.ui.notify(`${COMPLETE_SKIPPED} ${label}`, "info")
+  let body = ""
+  if (blank.empty) {
+    const typed = await ctx.ui.input(`${COMPLETE_BODY_TITLE} (${label})`)
+    if (typeof typed !== "string" || typed.trim() === "") return ctx.ui.notify(`${COMPLETE_SKIPPED} ${label}`, "info")
+    body = typed
+  }
+  const confirmed = await ctx.ui.confirm(`Complete ${label} as a ${type} note?`, COMPLETE_CONFIRM_MESSAGE)
+  if (!confirmed) return ctx.ui.notify(`${COMPLETE_SKIPPED} ${label}`, "info")
+  const result = await completeBlankMemory(
+    { vault, path: blank.path, expectedHash: blank.rawHash, type, body },
+    context,
+  )
+  if (!result.succeeded) return ctx.ui.notify(result.problems.join("\n"), "error")
+  const warnings = result.output.maintenanceProblems.map((problem) => `\nMaintenance warning: ${problem}`)
+  ctx.ui.notify(`${COMPLETED} ${label} as a ${type} note.${warnings.join("")}`, "info")
+}
+
+function isNoteType(value: string | undefined): value is (typeof BLANK_NOTE_TYPES)[number] {
+  return typeof value === "string" && BLANK_NOTE_TYPES.some((type) => type === value)
+}
+
+function embeddingProbeOf(ctx: MemoryPiContext, modelCachePath: string): EmbeddingProbe {
+  return {
+    modelCachePath,
+    async hasCredentials(provider) {
+      const key = await ctx.modelRegistry.getApiKeyForProvider(provider)
+      return typeof key === "string" && key !== ""
+    },
+  }
+}
+
+function decisionProbeOf(ctx: MemoryPiContext): DecisionProbe {
+  return {
+    hasClassifier: (provider, model) => typeof ctx.modelRegistry.findOfType("classifier", provider, model) === "object",
+    async hasCredentials(provider) {
+      const key = await ctx.modelRegistry.getApiKeyForProvider(provider)
+      return typeof key === "string" && key !== ""
+    },
+  }
+}