update: fmt + memoryに用いる言語の構成

crates/pod/src/pod.rs

@@ -2075,9 +2075,10 @@ impl<C: LlmClient, St: Store> Pod<C, St> {
             .or(manifest::defaults::MEMORY_EXTRACT_WORKER_MAX_TURNS);
 
         let client = self.build_extractor_client(memory_cfg)?;
+        let memory_language = memory_language(memory_cfg);
         let extract_system_prompt = self
             .prompts
-            .memory_extract_system()
+            .memory_extract_system(memory_language)
             .map_err(PodError::PromptCatalog)?;
         let mut extract_worker = Worker::new(client).system_prompt(extract_system_prompt);
         extract_worker.set_cache_key(Some(self.session_id.to_string()));
@@ -2276,13 +2277,15 @@ impl<C: LlmClient, St: Store> Pod<C, St> {
                 return Err(e);
             }
         };
-        let consolidation_system_prompt = match self.prompts.memory_consolidation_system() {
-            Ok(p) => p,
-            Err(e) => {
-                lock.release_only();
-                return Err(PodError::PromptCatalog(e));
-            }
-        };
+        let memory_language = memory_language(memory_cfg);
+        let consolidation_system_prompt =
+            match self.prompts.memory_consolidation_system(memory_language) {
+                Ok(p) => p,
+                Err(e) => {
+                    lock.release_only();
+                    return Err(PodError::PromptCatalog(e));
+                }
+            };
         let mut worker = Worker::new(client).system_prompt(consolidation_system_prompt);
         worker.set_cache_key(Some(self.session_id.to_string()));
 
@@ -2331,6 +2334,14 @@ impl<C: LlmClient, St: Store> Pod<C, St> {
     }
 }
 
+fn memory_language(cfg: &manifest::MemoryConfig) -> &str {
+    cfg.language
+        .as_deref()
+        .map(str::trim)
+        .filter(|language| !language.is_empty())
+        .unwrap_or(manifest::defaults::MEMORY_LANGUAGE)
+}
+
 /// Outcome of a single extract iteration. Internal to
 /// `try_post_run_extract` / `run_extract_once`.
 enum ExtractDecision {

crates/pod/src/prompt/catalog.rs

@@ -311,14 +311,17 @@ impl PromptCatalog {
         self.render(PodPrompt::CompactSystem, Value::UNDEFINED)
     }
 
-    /// Render `PodPrompt::MemoryExtractSystem` (no inputs).
-    pub fn memory_extract_system(&self) -> Result<String, CatalogError> {
-        self.render(PodPrompt::MemoryExtractSystem, Value::UNDEFINED)
+    /// Render `PodPrompt::MemoryExtractSystem` with `{{ language }}`.
+    pub fn memory_extract_system(&self, language: &str) -> Result<String, CatalogError> {
+        self.render(PodPrompt::MemoryExtractSystem, single("language", language))
     }
 
-    /// Render `PodPrompt::MemoryConsolidationSystem` (no inputs).
-    pub fn memory_consolidation_system(&self) -> Result<String, CatalogError> {
-        self.render(PodPrompt::MemoryConsolidationSystem, Value::UNDEFINED)
+    /// Render `PodPrompt::MemoryConsolidationSystem` with `{{ language }}`.
+    pub fn memory_consolidation_system(&self, language: &str) -> Result<String, CatalogError> {
+        self.render(
+            PodPrompt::MemoryConsolidationSystem,
+            single("language", language),
+        )
     }
 
     /// Render `PodPrompt::NotifyWrapper` with `{{ message }}`.
@@ -488,6 +491,15 @@ mod tests {
         assert!(rendered.contains("mark_read_required"));
     }
 
+    #[test]
+    fn memory_worker_prompts_include_language() {
+        let cat = PromptCatalog::builtins_only().unwrap();
+        let extract = cat.memory_extract_system("Japanese").unwrap();
+        let consolidate = cat.memory_consolidation_system("Japanese").unwrap();
+        assert!(extract.contains("`language`: `Japanese`"));
+        assert!(consolidate.contains("`language`: `Japanese`"));
+    }
+
     #[test]
     fn notify_wrapper_interpolates_message() {
         let cat = PromptCatalog::builtins_only().unwrap();

crates/pod/src/shared_state.rs

@@ -280,10 +280,7 @@ mod tests {
         assert_eq!(all.len(), 3);
         let alpha = state.list_knowledge_completions("alpha");
         assert_eq!(
-            alpha
-                .iter()
-                .map(|c| c.slug.as_str())
-                .collect::<Vec<_>>(),
+            alpha.iter().map(|c| c.slug.as_str()).collect::<Vec<_>>(),
             vec!["alpha", "alphabet"]
         );
         assert!(state.list_knowledge_completions("zzz").is_empty());