feat(memory): add CUSTOM as wizard MemoryOption and wire existing memories to new agents

Add 'custom' as a 4th MemoryOption in the create/add-agent wizards,
completing CUSTOM strategy support across all CLI flows. When adding
an agent to a project with existing memories, the template now
references all existing memories instead of always creating new ones.

- Add 'custom' to MemoryOption type, MEMORY_OPTIONS array, and all
  validation/help text across create and add-agent commands
- Add 'custom' case to mapGenerateInputToMemories (CUSTOM strategy,
  no default namespaces) and getMemoryLabel in wizard UI
- Add mapExistingMemoriesToProviders() to convert project Memory[]
  to MemoryProviderRenderConfig[] for template rendering
- Update mapGenerateConfigToRenderConfig to accept existing memories
  and merge them with new memory providers (deduped by name)
- Update writeAgentToProject to skip adding duplicate memories
- Wire existing project.memories through both add-agent paths
  (AgentPrimitive CLI + useAddAgent TUI hook)

Constraint: Strands Agent takes a single session_manager, so session.py
  references memoryProviders[0] as the primary memory
Rejected: Multi-select wizard for memory | template only supports one
  session_manager, all memory env vars already available at runtime
Confidence: high
Scope-risk: moderate

Author: aidandaly24

src/cli/commands/add/validate.ts

@@ -33,7 +33,7 @@ export interface ValidationResult {
 }
 
 // Constants
-const MEMORY_OPTIONS = ['none', 'shortTerm', 'longAndShortTerm'] as const;
+const MEMORY_OPTIONS = ['none', 'shortTerm', 'longAndShortTerm', 'custom'] as const;
 const VALID_STRATEGIES: readonly string[] = MemoryStrategyTypeSchema.options;
 
 /**
@@ -134,7 +134,7 @@ export function validateAddAgentOptions(options: AddAgentOptions): ValidationRes
     if (!MEMORY_OPTIONS.includes(options.memory as (typeof MEMORY_OPTIONS)[number])) {
       return {
         valid: false,
-        error: `Invalid memory option: ${options.memory}. Use none, shortTerm, or longAndShortTerm`,
+        error: `Invalid memory option: ${options.memory}. Use none, shortTerm, longAndShortTerm, or custom`,
       };
     }
     // Force import defaults
@@ -230,7 +230,7 @@ export function validateAddAgentOptions(options: AddAgentOptions): ValidationRes
     if (!MEMORY_OPTIONS.includes(options.memory as (typeof MEMORY_OPTIONS)[number])) {
       return {
         valid: false,
-        error: `Invalid memory option: ${options.memory}. Use none, shortTerm, or longAndShortTerm`,
+        error: `Invalid memory option: ${options.memory}. Use none, shortTerm, longAndShortTerm, or custom`,
       };
     }
   }

src/cli/commands/create/action.ts

@@ -120,7 +120,7 @@ export async function createProject(options: CreateProjectOptions): Promise<Crea
   }
 }
 
-type MemoryOption = 'none' | 'shortTerm' | 'longAndShortTerm';
+type MemoryOption = 'none' | 'shortTerm' | 'longAndShortTerm' | 'custom';
 
 export interface CreateWithAgentOptions {
   name: string;

src/cli/commands/create/command.tsx

@@ -128,7 +128,7 @@ async function handleCreateCLI(options: CreateOptions): Promise<void> {
         framework: options.framework as SDKFramework | undefined,
         modelProvider: options.modelProvider as ModelProvider | undefined,
         apiKey: options.apiKey,
-        memory: (options.memory as 'none' | 'shortTerm' | 'longAndShortTerm') ?? 'none',
+        memory: (options.memory as 'none' | 'shortTerm' | 'longAndShortTerm' | 'custom') ?? 'none',
         protocol: options.protocol as ProtocolMode | undefined,
         agentId: options.agentId,
         agentAliasId: options.agentAliasId,
@@ -167,7 +167,7 @@ export const registerCreate = (program: Command) => {
     )
     .option('--model-provider <provider>', 'Model provider (Bedrock, Anthropic, OpenAI, Gemini) [non-interactive]')
     .option('--api-key <key>', 'API key for non-Bedrock providers [non-interactive]')
-    .option('--memory <option>', 'Memory option (none, shortTerm, longAndShortTerm) [non-interactive]')
+    .option('--memory <option>', 'Memory option (none, shortTerm, longAndShortTerm, custom) [non-interactive]')
     .option('--protocol <protocol>', 'Protocol: HTTP, MCP, A2A (default: HTTP) [non-interactive]')
     .option('--type <type>', 'Agent type: create or import (default: create) [non-interactive]')
     .option('--agent-id <id>', 'Bedrock Agent ID (required for --type import) [non-interactive]')

src/cli/commands/create/validate.ts

@@ -20,7 +20,7 @@ export interface ValidationResult {
   error?: string;
 }
 
-const MEMORY_OPTIONS = ['none', 'shortTerm', 'longAndShortTerm'] as const;
+const MEMORY_OPTIONS = ['none', 'shortTerm', 'longAndShortTerm', 'custom'] as const;
 
 /** Check if a folder with the given name already exists in the directory */
 export function validateFolderNotExists(name: string, cwd: string): true | string {
@@ -71,7 +71,7 @@ export function validateCreateOptions(options: CreateOptions, cwd?: string): Val
     if (!MEMORY_OPTIONS.includes(options.memory as (typeof MEMORY_OPTIONS)[number])) {
       return {
         valid: false,
-        error: `Invalid memory option: ${options.memory}. Use none, shortTerm, or longAndShortTerm`,
+        error: `Invalid memory option: ${options.memory}. Use none, shortTerm, longAndShortTerm, or custom`,
       };
     }
     return { valid: true };
@@ -189,7 +189,7 @@ export function validateCreateOptions(options: CreateOptions, cwd?: string): Val
     if (!MEMORY_OPTIONS.includes(options.memory as (typeof MEMORY_OPTIONS)[number])) {
       return {
         valid: false,
-        error: `Invalid memory option: ${options.memory}. Use none, shortTerm, or longAndShortTerm`,
+        error: `Invalid memory option: ${options.memory}. Use none, shortTerm, longAndShortTerm, or custom`,
       };
     }
   }

src/cli/operations/agent/generate/index.ts

@@ -3,6 +3,7 @@ export {
   mapGenerateConfigToResources,
   mapGenerateConfigToRenderConfig,
   mapGenerateInputToMemories,
+  mapExistingMemoriesToProviders,
   mapModelProviderToCredentials,
   mapModelProviderToIdentityProviders,
   type GenerateConfigMappingResult,

src/cli/operations/agent/generate/schema-mapper.ts

@@ -75,6 +75,9 @@ export function mapGenerateInputToMemories(memory: MemoryOption, projectName: st
         ...(defaultNamespaces && { namespaces: defaultNamespaces }),
       });
     }
+  } else if (memory === 'custom') {
+    // Custom strategy has no default namespaces - user provides their own extraction logic
+    strategies.push({ type: 'CUSTOM' });
   }
 
   return [
@@ -241,29 +244,54 @@ async function mapGatewaysToGatewayProviders(): Promise<GatewayProviderRenderCon
   }
 }
 
+/**
+ * Maps existing Memory resources to memory providers for template rendering.
+ * Used when adding an agent to a project that already has memories defined.
+ */
+export function mapExistingMemoriesToProviders(memories: Memory[]): MemoryProviderRenderConfig[] {
+  return memories.map(m => ({
+    name: m.name,
+    envVarName: computeMemoryEnvVarName(m.name),
+    strategies: m.strategies.map(s => s.type),
+  }));
+}
+
 /**
  * Maps GenerateConfig to AgentRenderConfig for template rendering.
  * @param config - Generate config (note: config.projectName is actually the agent name)
  * @param identityProviders - Identity providers to include (caller controls credential naming)
+ * @param existingMemories - Existing project memories to wire to the agent template
  */
 export async function mapGenerateConfigToRenderConfig(
   config: GenerateConfig,
-  identityProviders: IdentityProviderRenderConfig[]
+  identityProviders: IdentityProviderRenderConfig[],
+  existingMemories?: Memory[]
 ): Promise<AgentRenderConfig> {
   const isMcp = config.protocol === 'MCP';
   const gatewayProviders = isMcp ? [] : await mapGatewaysToGatewayProviders();
 
+  // Build memory providers: existing memories first, then any new memory from the option.
+  // This ensures agents in existing projects reference all available memories.
+  const existingProviders = existingMemories?.length ? mapExistingMemoriesToProviders(existingMemories) : [];
+  const newProviders = mapMemoryOptionToMemoryProviders(config.memory, config.projectName);
+  const allProviders = [...existingProviders];
+  for (const np of newProviders) {
+    if (!allProviders.some(ep => ep.name === np.name)) {
+      allProviders.push(np);
+    }
+  }
+
   return {
     name: config.projectName,
     sdkFramework: config.sdk,
     targetLanguage: config.language,
     modelProvider: config.modelProvider,
-    hasMemory: isMcp ? false : config.memory !== 'none',
+    hasMemory: isMcp ? false : allProviders.length > 0,
     hasIdentity: isMcp ? false : identityProviders.length > 0,
     hasGateway: gatewayProviders.length > 0,
     isVpc: config.networkMode === 'VPC',
     buildType: config.buildType,
-    memoryProviders: isMcp ? [] : mapMemoryOptionToMemoryProviders(config.memory, config.projectName),
+    memoryProviders: isMcp ? [] : allProviders,
     identityProviders: isMcp ? [] : identityProviders,
     gatewayProviders,
     gatewayAuthTypes: [...new Set(gatewayProviders.map(g => g.authType))],

src/cli/operations/agent/generate/write-agent-to-project.ts

@@ -40,7 +40,10 @@ export async function writeAgentToProject(config: GenerateConfig, options?: Writ
 
     // Add resources to project
     project.agents.push(agent);
-    project.memories.push(...memories);
+
+    // Only add memories that don't already exist in the project (avoid duplicates)
+    const newMemories = memories.filter(m => !project.memories.some(em => em.name === m.name));
+    project.memories.push(...newMemories);
 
     // Handle credentials based on strategy
     if (strategy) {

src/cli/primitives/AgentPrimitive.tsx

@@ -194,7 +194,10 @@ export class AgentPrimitive extends BasePrimitive<AddAgentOptions, RemovableReso
       )
       .option('--model-provider <provider>', 'Model provider: Bedrock, Anthropic, OpenAI, Gemini [non-interactive]')
       .option('--api-key <key>', 'API key for non-Bedrock providers [non-interactive]')
-      .option('--memory <mem>', 'Memory: none, shortTerm, longAndShortTerm (create path only) [non-interactive]')
+      .option(
+        '--memory <mem>',
+        'Memory: none, shortTerm, longAndShortTerm, custom (create path only) [non-interactive]'
+      )
       .option('--protocol <protocol>', 'Protocol: HTTP, MCP, A2A (default: HTTP) [non-interactive]')
       .option('--code-location <path>', 'Path to existing code (BYO path only) [non-interactive]')
       .option('--entrypoint <file>', 'Entry file relative to code-location (BYO, default: main.py) [non-interactive]')
@@ -385,8 +388,8 @@ export class AgentPrimitive extends BasePrimitive<AddAgentOptions, RemovableReso
       ];
     }
 
-    // Render templates with correct identity provider
-    const renderConfig = await mapGenerateConfigToRenderConfig(generateConfig, identityProviders);
+    // Render templates with correct identity provider and existing project memories
+    const renderConfig = await mapGenerateConfigToRenderConfig(generateConfig, identityProviders, project.memories);
     const renderer = createRenderer(renderConfig);
     await renderer.render({ outputDir: projectRoot });
 

src/cli/tui/screens/agent/useAddAgent.ts

@@ -196,8 +196,8 @@ async function handleCreatePath(
     ];
   }
 
-  // Generate agent files with correct identity provider
-  const renderConfig = await mapGenerateConfigToRenderConfig(generateConfig, identityProviders);
+  // Generate agent files with correct identity provider and existing project memories
+  const renderConfig = await mapGenerateConfigToRenderConfig(generateConfig, identityProviders, project.memories);
   const renderer = createRenderer(renderConfig);
   await renderer.render({ outputDir: projectRoot });
 

src/cli/tui/screens/generate/GenerateWizardUI.tsx

@@ -318,6 +318,8 @@ function getMemoryLabel(memory: MemoryOption): string {
       return 'Short-term';
     case 'longAndShortTerm':
       return 'Long-term + short-term';
+    case 'custom':
+      return 'Custom';
   }
 }