feat: Mode system with inheritance and multilingual support (#412)
* feat: add domain management system with support for multiple domain profiles
- Introduced DomainManager class for loading and managing domain profiles.
- Added support for a default domain ('code') and fallback mechanisms.
- Implemented domain configuration validation and error handling.
- Created types for domain configuration, observation types, and concepts.
- Added new directory for domain profiles and ensured its existence.
- Updated SettingsDefaultsManager to include CLAUDE_MEM_DOMAIN setting.
* Refactor domain management to mode management
- Removed DomainManager class and replaced it with ModeManager for better clarity and functionality.
- Updated types from DomainConfig to ModeConfig and DomainPrompts to ModePrompts.
- Changed references from domains to modes in the settings and paths.
- Ensured backward compatibility by maintaining the fallback mechanism to the 'code' mode.
* feat: add migration 008 to support mode-agnostic observations and refactor service layer references in documentation
* feat: add new modes for code development and email investigation with detailed observation types and concepts
* Refactor observation parsing and prompt generation to incorporate mode-specific configurations
- Updated `parseObservations` function to use 'observation' as a universal fallback type instead of 'change', utilizing active mode's valid observation types.
- Modified `buildInitPrompt` and `buildContinuationPrompt` functions to accept a `ModeConfig` parameter, allowing for dynamic prompt content based on the active mode.
- Enhanced `ModePrompts` interface to include additional guidance for observers, such as recording focus and skip guidance.
- Adjusted the SDKAgent to load the active mode and pass it to prompt generation functions, ensuring prompts are tailored to the current mode's context.
* fix: correct mode prompt injection to preserve exact wording and type list visibility
- Add script to extract prompts from main branch prompts.ts into code.yaml
- Fix prompts.ts to show type list in XML template (e.g., "[ bugfix | feature | ... ]")
- Keep 'change' as fallback type in parser.ts (maintain backwards compatibility)
- Regenerate code.yaml with exact wording from original hardcoded prompts
- Build succeeds with no TypeScript errors
* fix: update ModeManager to load JSON mode files and improve validation
- Changed ModeManager to load mode configurations from JSON files instead of YAML.
- Removed the requirement for an "observation" type and updated validation to require at least one observation type.
- Updated fallback behavior in the parser to use the first type from the active mode's type list.
- Added comprehensive tests for mode loading, prompt injection, and parser integration, ensuring correct behavior across different modes.
- Introduced new mode JSON files for "Code Development" and "Email Investigation" with detailed observation types and prompts.
* Add mode configuration loading and update licensing information for Ragtime
- Implemented loading of mode configuration in WorkerService before database initialization.
- Added PolyForm Noncommercial License 1.0.0 to Ragtime directory.
- Created README.md for Ragtime with licensing details and usage guidelines.
* fix: add datasets directory to .gitignore to prevent accidental commits
* refactor: remove unused plugin package.json file
* chore: add package.json for claude-mem plugin with version 7.4.5
* refactor: remove outdated tests and improve error handling
- Deleted tests for ChromaSync error handling, smart install, strip memory tags, and user prompt tag stripping due to redundancy or outdated logic.
- Removed vitest configuration as it is no longer needed.
- Added a comprehensive implementation plan for fixing the modes system, addressing critical issues and improving functionality.
- Created a detailed test analysis report highlighting the quality and effectiveness of the current test suite, identifying areas for improvement.
- Introduced a new plugin package.json for runtime dependencies related to claude-mem hooks.
* refactor: remove parser regression tests to streamline codebase
* docs: update CLAUDE.md to clarify test management and changelog generation
* refactor: remove migration008 for mode-agnostic observations
* Refactor observation type handling to use ModeManager for icons and emojis
- Removed direct mappings of observation types to icons and work emojis in context-generator, FormattingService, SearchManager, and TimelineService.
- Integrated ModeManager to dynamically retrieve icons and emojis based on the active mode.
- Improved maintainability by centralizing the logic for observation type representation.
* Refactor observation metadata constants and update context generator
- Removed the explicit declaration of OBSERVATION_TYPES and OBSERVATION_CONCEPTS from observation-metadata.ts.
- Introduced fallback default strings for DEFAULT_OBSERVATION_TYPES_STRING and DEFAULT_OBSERVATION_CONCEPTS_STRING.
- Updated context-generator.ts to utilize observation types and concepts from ModeManager instead of constants.
* refactor: remove intermediate error handling from hooks (Phase 1)
Apply "fail fast" error handling strategy - errors propagate and crash loud
instead of being caught, wrapped, and re-thrown at intermediate layers.
Changes:
- Remove try/catch around fetch calls in all hooks - let errors throw
- Add try/catch ONLY around JSON.parse at entry points
- Delete error-handler.ts and hook-error-handler.ts (no longer needed)
- Update worker-utils.ts: functions now throw instead of returning null
- Update transcript-parser.ts: throw on missing path, empty file, malformed JSON
- Remove all handleWorkerError, handleFetchError imports
Philosophy: If something breaks, we KNOW it broke. No silent failures.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
* refactor: remove intermediate error handling from worker service (Phase 2)
Apply "fail fast" error handling strategy to worker service layer.
Changes:
- worker-service.ts: Remove try/catch from version endpoint, cleanup,
MCP close, process enumeration, force kill, and isAlive check
- SessionRoutes.ts: Remove try/catch from JSON.stringify calls, remove
.catch() from Chroma sync and SDK agent calls
- SettingsRoutes.ts: Remove try/catch from toggleMcp()
- DatabaseManager.ts: Remove .catch() from backfill and close operations
- SDKAgent.ts: Keep outer try/catch (top-level), remove .catch() from
Chroma sync operations
- SSEBroadcaster.ts: Remove try/catch from broadcast and sendToClient
Philosophy: Errors propagate and crash loud. BaseRouteHandler.wrapHandler
provides top-level catching for HTTP routes.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
* refactor: remove error swallowing from SQLite services (Phase 3)
Apply "fail fast" error handling strategy to database layer.
SessionStore.ts migrations:
- ensureWorkerPortColumn(): Remove outer try/catch, let it throw
- ensurePromptTrackingColumns(): Remove outer try/catch, let it throw
- removeSessionSummariesUniqueConstraint(): Keep inner transaction
rollback, remove outer catch
- addObservationHierarchicalFields(): Remove outer try/catch
- makeObservationsTextNullable(): Keep inner transaction rollback,
remove outer catch
- createUserPromptsTable(): Keep inner transaction rollback, remove
outer catch
- getFilesForSession(): Remove try/catch around JSON.parse
SessionSearch.ts:
- ensureFTSTables(): Remove try/catch, let it throw
Philosophy: Migration errors that are swallowed mean we think the
database is fine when it's not. Keep only inner transaction rollback
try/catch blocks.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
* refactor: remove error hiding from utilities (Phase 4)
Apply "fail fast" error handling strategy to utility layer.
logger.ts:
- formatTool(): Remove try/catch, let JSON.parse throw on malformed input
context-generator.ts:
- loadContextConfig(): Remove try/catch, let parseInt throw on invalid settings
- Transcript extraction: Remove try/catch, let file read errors propagate
ChromaSync.ts:
- close(): Remove nested try/catch blocks, let close errors propagate
Philosophy: No silent fallbacks or hidden defaults. If something breaks,
we know it broke immediately.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
* feat: serve static UI assets and update package root path
- Added middleware to serve static UI assets (JS, CSS, fonts, etc.) in ViewerRoutes.
- Updated getPackageRoot function to correctly return the package root directory as one level up from the current directory.
* feat: Enhance mode loading with inheritance support
- Introduced parseInheritance method to handle parent--override mode IDs.
- Added deepMerge method for recursively merging mode configurations.
- Updated loadMode method to support inheritance, loading parent modes and applying overrides.
- Improved error handling for missing mode files and logging for better traceability.
* fix(modes): correct inheritance file resolution and path handling
* Refactor code structure for improved readability and maintainability
* feat: Add mode configuration documentation and examples
* fix: Improve concurrency handling in translateReadme function
* Refactor SDK prompts to enhance clarity and structure
- Updated the `buildInitPrompt` and `buildContinuationPrompt` functions in `prompts.ts` to improve the organization of prompt components, including the addition of language instructions and footer messages.
- Removed redundant instructions and emphasized the importance of recording observations.
- Modified the `ModePrompts` interface in `types.ts` to include new properties for system identity, language instructions, and output format header, ensuring better flexibility and clarity in prompt generation.
* Enhance prompts with language instructions and XML formatting
- Updated `buildInitPrompt`, `buildSummaryPrompt`, and `buildContinuationPrompt` functions to include detailed language instructions in XML comments.
- Ensured that language instructions guide users to keep XML tags in English while writing content in the specified language.
- Modified the `buildSummaryPrompt` function to accept `mode` as a parameter for consistency.
- Adjusted the call to `buildSummaryPrompt` in `SDKAgent` to pass the `mode` argument.
* Refactor XML prompt generation in SDK
- Updated the buildInitPrompt, buildSummaryPrompt, and buildContinuationPrompt functions to use new placeholders for XML elements, improving maintainability and readability.
- Removed redundant language instructions in comments for clarity.
- Added new properties to ModePrompts interface for better structure and organization of XML placeholders and section headers.
* feat: Update observation prompts and structure across multiple languages
* chore: Remove planning docs and update Ragtime README
Remove ephemeral development artifacts:
- .claude/plans/modes-system-fixes.md
- .claude/test-analysis-report.md
- PROMPT_INJECTION_ANALYSIS.md
Update ragtime/README.md to explain:
- Feature is not yet implemented
- Dependency on modes system (now complete in PR #412)
- Ready to be scripted out in future release
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
* fix: Move summary prompts to mode files for multilingual support
Summary prompts were hardcoded in English in prompts.ts, breaking
multilingual support. Now properly mode-based:
- Added summary_instruction, summary_context_label,
summary_format_instruction, summary_footer to code.json
- Updated buildSummaryPrompt() to use mode fields instead of hardcoded text
- Added summary_footer with language instructions to all 10 language modes
- Language modes keep English prompts + language requirement footer
This fixes the gaslighting where we claimed full multilingual support
but summaries were still generated in English.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
* chore: Clean up README by removing local preview instructions and streamlining beta features section
* Add translated README files for Ukrainian, Vietnamese, and Chinese languages
* Add new language modes for code development in multiple languages
- Introduced JSON configurations for Code Development in Greek, Finnish, Hebrew, Hindi, Hungarian, Indonesian, Italian, Dutch, Norwegian, Polish, Brazilian Portuguese, Romanian, Swedish, Turkish, and Ukrainian.
- Each configuration includes prompts for observations, summaries, and instructions tailored to the respective language.
- Ensured that all prompts emphasize the importance of generating observations without referencing the agent's actions.
* Add multilingual support links to README files in various languages
- Updated README.id.md, README.it.md, README.ja.md, README.ko.md, README.nl.md, README.no.md, README.pl.md, README.pt-br.md, README.ro.md, README.ru.md, README.sv.md, README.th.md, README.tr.md, README.uk.md, README.vi.md, and README.zh.md to include links to other language versions.
- Each README now features a centered paragraph with flags and links for easy navigation between different language documents.
---------
Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Alex Newman
@@ -0,0 +1,254 @@
|
||||
/**
|
||||
* ModeManager - Singleton for loading and managing mode profiles
|
||||
*
|
||||
* Mode profiles define observation types, concepts, and prompts for different use cases.
|
||||
* Default mode is 'code' (software development). Other modes like 'email-investigation'
|
||||
* can be selected via CLAUDE_MEM_MODE setting.
|
||||
*/
|
||||
|
||||
import { readFileSync, existsSync } from 'fs';
|
||||
import { join } from 'path';
|
||||
import type { ModeConfig, ObservationType, ObservationConcept } from './types.js';
|
||||
import { logger } from '../../utils/logger.js';
|
||||
import { getPackageRoot } from '../../shared/paths.js';
|
||||
|
||||
export class ModeManager {
|
||||
private static instance: ModeManager | null = null;
|
||||
private activeMode: ModeConfig | null = null;
|
||||
private modesDir: string;
|
||||
|
||||
private constructor() {
|
||||
// Modes are in plugin/modes/
|
||||
// getPackageRoot() points to plugin/ in production and src/ in development
|
||||
// We want to ensure we find the modes directory which is at the project root/plugin/modes
|
||||
const packageRoot = getPackageRoot();
|
||||
|
||||
// Check for plugin/modes relative to package root (covers both dev and prod if paths are right)
|
||||
const possiblePaths = [
|
||||
join(packageRoot, 'modes'), // Production (plugin/modes)
|
||||
join(packageRoot, '..', 'plugin', 'modes'), // Development (src/../plugin/modes)
|
||||
];
|
||||
|
||||
const foundPath = possiblePaths.find(p => existsSync(p));
|
||||
this.modesDir = foundPath || possiblePaths[0];
|
||||
}
|
||||
|
||||
/**
|
||||
* Get singleton instance
|
||||
*/
|
||||
static getInstance(): ModeManager {
|
||||
if (!ModeManager.instance) {
|
||||
ModeManager.instance = new ModeManager();
|
||||
}
|
||||
return ModeManager.instance;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse mode ID for inheritance pattern (parent--override)
|
||||
*/
|
||||
private parseInheritance(modeId: string): {
|
||||
hasParent: boolean;
|
||||
parentId: string;
|
||||
overrideId: string;
|
||||
} {
|
||||
const parts = modeId.split('--');
|
||||
|
||||
if (parts.length === 1) {
|
||||
return { hasParent: false, parentId: '', overrideId: '' };
|
||||
}
|
||||
|
||||
// Support only one level: code--ko, not code--ko--verbose
|
||||
if (parts.length > 2) {
|
||||
throw new Error(
|
||||
`Invalid mode inheritance: ${modeId}. Only one level of inheritance supported (parent--override)`
|
||||
);
|
||||
}
|
||||
|
||||
return {
|
||||
hasParent: true,
|
||||
parentId: parts[0],
|
||||
overrideId: modeId // Use the full modeId (e.g., code--es) to find the override file
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if value is a plain object (not array, not null)
|
||||
*/
|
||||
private isPlainObject(value: unknown): boolean {
|
||||
return (
|
||||
value !== null &&
|
||||
typeof value === 'object' &&
|
||||
!Array.isArray(value)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Deep merge two objects
|
||||
* - Recursively merge nested objects
|
||||
* - Replace arrays completely (no merging)
|
||||
* - Override primitives
|
||||
*/
|
||||
private deepMerge<T>(base: T, override: Partial<T>): T {
|
||||
const result = { ...base } as T;
|
||||
|
||||
for (const key in override) {
|
||||
const overrideValue = override[key];
|
||||
const baseValue = base[key];
|
||||
|
||||
if (this.isPlainObject(overrideValue) && this.isPlainObject(baseValue)) {
|
||||
// Recursively merge nested objects
|
||||
result[key] = this.deepMerge(baseValue, overrideValue as any);
|
||||
} else {
|
||||
// Replace arrays and primitives completely
|
||||
result[key] = overrideValue as T[Extract<keyof T, string>];
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Load a mode file from disk without inheritance processing
|
||||
*/
|
||||
private loadModeFile(modeId: string): ModeConfig {
|
||||
const modePath = join(this.modesDir, `${modeId}.json`);
|
||||
|
||||
if (!existsSync(modePath)) {
|
||||
throw new Error(`Mode file not found: ${modePath}`);
|
||||
}
|
||||
|
||||
const jsonContent = readFileSync(modePath, 'utf-8');
|
||||
return JSON.parse(jsonContent) as ModeConfig;
|
||||
}
|
||||
|
||||
/**
|
||||
* Load a mode profile by ID with inheritance support
|
||||
* Caches the result for subsequent calls
|
||||
*
|
||||
* Supports inheritance via parent--override pattern (e.g., code--ko)
|
||||
* - Loads parent mode recursively
|
||||
* - Loads override file from modes directory
|
||||
* - Deep merges override onto parent
|
||||
*/
|
||||
loadMode(modeId: string): ModeConfig {
|
||||
const inheritance = this.parseInheritance(modeId);
|
||||
|
||||
// No inheritance - load file directly (existing behavior)
|
||||
if (!inheritance.hasParent) {
|
||||
try {
|
||||
const mode = this.loadModeFile(modeId);
|
||||
this.activeMode = mode;
|
||||
logger.debug('SYSTEM', `Loaded mode: ${mode.name} (${modeId})`, undefined, {
|
||||
types: mode.observation_types.map(t => t.id),
|
||||
concepts: mode.observation_concepts.map(c => c.id)
|
||||
});
|
||||
return mode;
|
||||
} catch (error) {
|
||||
logger.warn('SYSTEM', `Mode file not found: ${modeId}, falling back to 'code'`);
|
||||
// If we're already trying to load 'code', throw to prevent infinite recursion
|
||||
if (modeId === 'code') {
|
||||
throw new Error('Critical: code.json mode file missing');
|
||||
}
|
||||
return this.loadMode('code');
|
||||
}
|
||||
}
|
||||
|
||||
// Has inheritance - load parent and merge with override
|
||||
const { parentId, overrideId } = inheritance;
|
||||
|
||||
// Load parent mode recursively
|
||||
let parentMode: ModeConfig;
|
||||
try {
|
||||
parentMode = this.loadMode(parentId);
|
||||
} catch (error) {
|
||||
logger.warn('SYSTEM', `Parent mode '${parentId}' not found for ${modeId}, falling back to 'code'`);
|
||||
parentMode = this.loadMode('code');
|
||||
}
|
||||
|
||||
// Load override file
|
||||
let overrideConfig: Partial<ModeConfig>;
|
||||
try {
|
||||
overrideConfig = this.loadModeFile(overrideId);
|
||||
logger.debug('SYSTEM', `Loaded override file: ${overrideId} for parent ${parentId}`);
|
||||
} catch (error) {
|
||||
logger.warn('SYSTEM', `Override file '${overrideId}' not found, using parent mode '${parentId}' only`);
|
||||
this.activeMode = parentMode;
|
||||
return parentMode;
|
||||
}
|
||||
|
||||
// Validate override file loaded successfully
|
||||
if (!overrideConfig) {
|
||||
logger.warn('SYSTEM', `Invalid override file: ${overrideId}, using parent mode '${parentId}' only`);
|
||||
this.activeMode = parentMode;
|
||||
return parentMode;
|
||||
}
|
||||
|
||||
// Deep merge override onto parent
|
||||
const mergedMode = this.deepMerge(parentMode, overrideConfig);
|
||||
this.activeMode = mergedMode;
|
||||
|
||||
logger.debug('SYSTEM', `Loaded mode with inheritance: ${mergedMode.name} (${modeId} = ${parentId} + ${overrideId})`, undefined, {
|
||||
parent: parentId,
|
||||
override: overrideId,
|
||||
types: mergedMode.observation_types.map(t => t.id),
|
||||
concepts: mergedMode.observation_concepts.map(c => c.id)
|
||||
});
|
||||
|
||||
return mergedMode;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get currently active mode
|
||||
*/
|
||||
getActiveMode(): ModeConfig {
|
||||
if (!this.activeMode) {
|
||||
throw new Error('No mode loaded. Call loadMode() first.');
|
||||
}
|
||||
return this.activeMode;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all observation types from active mode
|
||||
*/
|
||||
getObservationTypes(): ObservationType[] {
|
||||
return this.getActiveMode().observation_types;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all observation concepts from active mode
|
||||
*/
|
||||
getObservationConcepts(): ObservationConcept[] {
|
||||
return this.getActiveMode().observation_concepts;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get icon for a specific observation type
|
||||
*/
|
||||
getTypeIcon(typeId: string): string {
|
||||
const type = this.getObservationTypes().find(t => t.id === typeId);
|
||||
return type?.emoji || '📝';
|
||||
}
|
||||
|
||||
/**
|
||||
* Get work emoji for a specific observation type
|
||||
*/
|
||||
getWorkEmoji(typeId: string): string {
|
||||
const type = this.getObservationTypes().find(t => t.id === typeId);
|
||||
return type?.work_emoji || '📝';
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate that a type ID exists in the active mode
|
||||
*/
|
||||
validateType(typeId: string): boolean {
|
||||
return this.getObservationTypes().some(t => t.id === typeId);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get label for a specific observation type
|
||||
*/
|
||||
getTypeLabel(typeId: string): string {
|
||||
const type = this.getObservationTypes().find(t => t.id === typeId);
|
||||
return type?.label || typeId;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
/**
|
||||
* TypeScript interfaces for mode configuration system
|
||||
*/
|
||||
|
||||
export interface ObservationType {
|
||||
id: string;
|
||||
label: string;
|
||||
description: string;
|
||||
emoji: string;
|
||||
work_emoji: string;
|
||||
}
|
||||
|
||||
export interface ObservationConcept {
|
||||
id: string;
|
||||
label: string;
|
||||
description: string;
|
||||
}
|
||||
|
||||
export interface ModePrompts {
|
||||
system_identity: string; // Base persona and role definition
|
||||
language_instruction?: string; // Optional language constraints (e.g., "Write in Korean")
|
||||
spatial_awareness: string; // Working directory context guidance
|
||||
observer_role: string; // What the observer's job is in this mode
|
||||
recording_focus: string; // What to record and how to think about it
|
||||
skip_guidance: string; // What to skip recording
|
||||
type_guidance: string; // Valid observation types for this mode
|
||||
concept_guidance: string; // Valid concept categories for this mode
|
||||
field_guidance: string; // Guidance for facts/files fields
|
||||
output_format_header: string; // Text introducing the XML schema
|
||||
format_examples: string; // Optional additional XML examples (empty string if not needed)
|
||||
footer: string; // Closing instructions and encouragement
|
||||
|
||||
// Observation XML placeholders
|
||||
xml_title_placeholder: string; // e.g., "[**title**: Short title capturing the core action or topic]"
|
||||
xml_subtitle_placeholder: string; // e.g., "[**subtitle**: One sentence explanation (max 24 words)]"
|
||||
xml_fact_placeholder: string; // e.g., "[Concise, self-contained statement]"
|
||||
xml_narrative_placeholder: string; // e.g., "[**narrative**: Full context: What was done, how it works, why it matters]"
|
||||
xml_concept_placeholder: string; // e.g., "[knowledge-type-category]"
|
||||
xml_file_placeholder: string; // e.g., "[path/to/file]"
|
||||
|
||||
// Summary XML placeholders
|
||||
xml_summary_request_placeholder: string; // e.g., "[Short title capturing the user's request AND...]"
|
||||
xml_summary_investigated_placeholder: string; // e.g., "[What has been explored so far? What was examined?]"
|
||||
xml_summary_learned_placeholder: string; // e.g., "[What have you learned about how things work?]"
|
||||
xml_summary_completed_placeholder: string; // e.g., "[What work has been completed so far? What has shipped or changed?]"
|
||||
xml_summary_next_steps_placeholder: string; // e.g., "[What are you actively working on or planning to work on next in this session?]"
|
||||
xml_summary_notes_placeholder: string; // e.g., "[Additional insights or observations about the current progress]"
|
||||
|
||||
// Section headers (with separator lines)
|
||||
header_memory_start: string; // e.g., "MEMORY PROCESSING START\n======================="
|
||||
header_memory_continued: string; // e.g., "MEMORY PROCESSING CONTINUED\n==========================="
|
||||
header_summary_checkpoint: string; // e.g., "PROGRESS SUMMARY CHECKPOINT\n==========================="
|
||||
|
||||
// Continuation prompts
|
||||
continuation_greeting: string; // e.g., "Hello memory agent, you are continuing to observe the primary Claude session."
|
||||
continuation_instruction: string; // e.g., "IMPORTANT: Continue generating observations from tool use messages using the XML structure below."
|
||||
|
||||
// Summary prompts
|
||||
summary_instruction: string; // Instructions for writing progress summary
|
||||
summary_context_label: string; // Label for Claude's response section (e.g., "Claude's Full Response to User:")
|
||||
summary_format_instruction: string; // Instruction to use XML format (e.g., "Respond in this XML format:")
|
||||
summary_footer: string; // Footer with closing instructions and language requirement
|
||||
}
|
||||
|
||||
export interface ModeConfig {
|
||||
name: string;
|
||||
description: string;
|
||||
version: string;
|
||||
observation_types: ObservationType[];
|
||||
observation_concepts: ObservationConcept[];
|
||||
prompts: ModePrompts;
|
||||
}
|
||||
Reference in New Issue
Block a user