fix: remove CUSTOM memory strategy temporarily

src/assets/__tests__/__snapshots__/assets.snapshot.test.ts.snap

@@ -2829,7 +2829,7 @@ file maps to a JSON config file and includes validation constraints as comments.
 - **BuildType**: \`'CodeZip'\` | \`'Container'\`
 - **NetworkMode**: \`'PUBLIC'\` | \`'PRIVATE'\`
 - **RuntimeVersion**: \`'PYTHON_3_12'\` | \`'PYTHON_3_13'\` | \`'NODE_18'\` | \`'NODE_20'\` | \`'NODE_22'\`
-- **MemoryStrategyType**: \`'SEMANTIC'\` | \`'SUMMARIZATION'\` | \`'USER_PREFERENCE'\` | \`'CUSTOM'\`
+- **MemoryStrategyType**: \`'SEMANTIC'\` | \`'SUMMARIZATION'\` | \`'USER_PREFERENCE'\`
 
 ### Supported Frameworks (for template agents)
 

src/assets/agents/AGENTS.md

@@ -63,7 +63,7 @@ file maps to a JSON config file and includes validation constraints as comments.
 - **BuildType**: `'CodeZip'` | `'Container'`
 - **NetworkMode**: `'PUBLIC'` | `'PRIVATE'`
 - **RuntimeVersion**: `'PYTHON_3_12'` | `'PYTHON_3_13'` | `'NODE_18'` | `'NODE_20'` | `'NODE_22'`
-- **MemoryStrategyType**: `'SEMANTIC'` | `'SUMMARIZATION'` | `'USER_PREFERENCE'` | `'CUSTOM'`
+- **MemoryStrategyType**: `'SEMANTIC'` | `'SUMMARIZATION'` | `'USER_PREFERENCE'`
 
 ### Supported Frameworks (for template agents)
 

src/cli/commands/add/__tests__/add-memory.test.ts

@@ -50,6 +50,18 @@ describe('add memory command', () => {
  expect(json.success).toBe(false);
  expect(json.error.includes('INVALID'), `Error: ${json.error}`).toBeTruthy();
  });
+
+ // Issue #235: CUSTOM strategy has been removed
+ it('rejects CUSTOM strategy', async () => {
+ const result = await runCLI(
+ ['add', 'memory', '--name', 'testCustom', '--strategies', 'CUSTOM', '--json'],
+ projectDir
+ );
+ expect(result.exitCode).toBe(1);
+ const json = JSON.parse(result.stdout);
+ expect(json.success).toBe(false);
+ expect(json.error.includes('CUSTOM'), `Error: ${json.error}`).toBeTruthy();
+ });
  });
 
  describe('memory creation', () => {

src/cli/commands/add/__tests__/validate.test.ts

@@ -313,9 +313,51 @@ describe('validate', () => {
  expect(validateAddMemoryOptions(validMemoryOptions)).toEqual({ valid: true });
  // Test all valid strategies
  expect(
- validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION,USER_PREFERENCE,CUSTOM' })
+ validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION,USER_PREFERENCE' })
  ).toEqual({ valid: true });
  });
+
+ // AC23: CUSTOM strategy is not supported (Issue #235)
+ it('rejects CUSTOM strategy', () => {
+ const result = validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'CUSTOM' });
+ expect(result.valid).toBe(false);
+ expect(result.error).toContain('Invalid strategy: CUSTOM');
+ });
+
+ it('rejects CUSTOM even when mixed with valid strategies', () => {
+ const result = validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,CUSTOM' });
+ expect(result.valid).toBe(false);
+ expect(result.error).toContain('Invalid strategy: CUSTOM');
+ });
+
+ // AC24: Each individual valid strategy should pass
+ it('accepts each valid strategy individually', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC' })).toEqual({ valid: true });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SUMMARIZATION' })).toEqual({ valid: true });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ });
+
+ // AC25: Valid strategy combinations should pass
+ it('accepts valid strategy combinations', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION' })).toEqual({
+ valid: true,
+ });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SUMMARIZATION,USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ });
+
+ // AC26: Strategies with whitespace should be handled
+ it('handles strategies with whitespace', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: ' SEMANTIC , SUMMARIZATION ' })).toEqual({
+ valid: true,
+ });
+ });
  });
 
  describe('validateAddIdentityOptions', () => {

src/cli/commands/add/command.tsx

@@ -316,7 +316,7 @@ export function registerAdd(program: Command) {
  .option('--name <name>', 'Memory name [non-interactive]')
  .option(
  '--strategies <types>',
- 'Comma-separated strategies: SEMANTIC, SUMMARIZATION, USER_PREFERENCE, CUSTOM [non-interactive]'
+ 'Comma-separated strategies: SEMANTIC, SUMMARIZATION, USER_PREFERENCE [non-interactive]'
  )
  .option('--expiry <days>', 'Event expiry duration in days (default: 30) [non-interactive]', parseInt)
  .option('--json', 'Output as JSON [non-interactive]')

src/cli/commands/add/validate.ts

@@ -22,7 +22,7 @@ export interface ValidationResult {
 // Constants
 const MEMORY_OPTIONS = ['none', 'shortTerm', 'longAndShortTerm'] as const;
 const OIDC_WELL_KNOWN_SUFFIX = '/.well-known/openid-configuration';
-const VALID_STRATEGIES = ['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE', 'CUSTOM'];
+const VALID_STRATEGIES = ['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE'];
 
 // Agent validation
 export function validateAddAgentOptions(options: AddAgentOptions): ValidationResult {

src/cli/tui/screens/memory/types.ts

@@ -32,7 +32,6 @@ const STRATEGY_DESCRIPTIONS: Record<MemoryStrategyType, string> = {
  SEMANTIC: 'Vector-based semantic search over memories',
  SUMMARIZATION: 'Compress and summarize conversation context',
  USER_PREFERENCE: 'Track and recall user preferences',
- CUSTOM: 'Custom memory strategy implementation',
 };
 
 export const MEMORY_STRATEGY_OPTIONS = MemoryStrategyTypeSchema.options.map(type => ({

src/schema/llm-compacted/agentcore.ts

@@ -27,7 +27,7 @@ type PythonRuntime = 'PYTHON_3_10' | 'PYTHON_3_11' | 'PYTHON_3_12' | 'PYTHON_3_1
 type NodeRuntime = 'NODE_18' | 'NODE_20' | 'NODE_22';
 type RuntimeVersion = PythonRuntime | NodeRuntime;
 type NetworkMode = 'PUBLIC' | 'PRIVATE';
-type MemoryStrategyType = 'SEMANTIC' | 'SUMMARIZATION' | 'USER_PREFERENCE' | 'CUSTOM';
+type MemoryStrategyType = 'SEMANTIC' | 'SUMMARIZATION' | 'USER_PREFERENCE';
 
 // ─────────────────────────────────────────────────────────────────────────────
 // AGENT

src/schema/schemas/primitives/__tests__/memory.test.ts

@@ -0,0 +1,89 @@
+import { DEFAULT_STRATEGY_NAMESPACES, MemoryStrategySchema, MemoryStrategyTypeSchema } from '../memory';
+import { describe, expect, it } from 'vitest';
+
+describe('MemoryStrategyTypeSchema', () => {
+ describe('valid strategy types', () => {
+ it('accepts SEMANTIC', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('SEMANTIC').success).toBe(true);
+ });
+
+ it('accepts SUMMARIZATION', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('SUMMARIZATION').success).toBe(true);
+ });
+
+ it('accepts USER_PREFERENCE', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('USER_PREFERENCE').success).toBe(true);
+ });
+ });
+
+ describe('invalid strategy types', () => {
+ // Issue #235: CUSTOM strategy has been removed
+ it('rejects CUSTOM strategy', () => {
+ const result = MemoryStrategyTypeSchema.safeParse('CUSTOM');
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects arbitrary invalid strategies', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('INVALID').success).toBe(false);
+ expect(MemoryStrategyTypeSchema.safeParse('').success).toBe(false);
+ expect(MemoryStrategyTypeSchema.safeParse('semantic').success).toBe(false); // lowercase
+ });
+ });
+
+ describe('schema options', () => {
+ it('only contains three valid strategies', () => {
+ expect(MemoryStrategyTypeSchema.options).toEqual(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE']);
+ expect(MemoryStrategyTypeSchema.options).not.toContain('CUSTOM');
+ });
+ });
+});
+
+describe('MemoryStrategySchema', () => {
+ it('validates strategy with required type field', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'SEMANTIC' });
+ expect(result.success).toBe(true);
+ });
+
+ it('validates strategy with optional fields', () => {
+ const result = MemoryStrategySchema.safeParse({
+ type: 'SEMANTIC',
+ name: 'myStrategy',
+ description: 'A description',
+ namespaces: ['/users/{actorId}/facts'],
+ });
+ expect(result.success).toBe(true);
+ });
+
+ it('rejects strategy with CUSTOM type', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'CUSTOM' });
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects strategy with invalid type', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'INVALID' });
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects strategy without type', () => {
+ const result = MemoryStrategySchema.safeParse({ name: 'myStrategy' });
+ expect(result.success).toBe(false);
+ });
+});
+
+describe('DEFAULT_STRATEGY_NAMESPACES', () => {
+ it('has default namespaces for SEMANTIC', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.SEMANTIC).toEqual(['/users/{actorId}/facts']);
+ });
+
+ it('has default namespaces for USER_PREFERENCE', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.USER_PREFERENCE).toEqual(['/users/{actorId}/preferences']);
+ });
+
+ it('has default namespaces for SUMMARIZATION', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.SUMMARIZATION).toEqual(['/summaries/{actorId}/{sessionId}']);
+ });
+
+ it('does not have default namespaces for CUSTOM (removed)', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES).not.toHaveProperty('CUSTOM');
+ });
+});

src/schema/schemas/primitives/memory.ts

@@ -10,16 +10,14 @@ import { z } from 'zod';
  * - SEMANTIC → SemanticMemoryStrategy
  * - SUMMARIZATION → SummaryMemoryStrategy (note: CloudFormation uses "Summary")
  * - USER_PREFERENCE → UserPreferenceMemoryStrategy
- * - CUSTOM → CustomMemoryStrategy
  * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-bedrockagentcore-memory-memorystrategy.html
  */
-export const MemoryStrategyTypeSchema = z.enum(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE', 'CUSTOM']);
+export const MemoryStrategyTypeSchema = z.enum(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE']);
 export type MemoryStrategyType = z.infer<typeof MemoryStrategyTypeSchema>;
 
 /**
  * Default namespaces for each memory strategy type.
  * These match the patterns generated in CLI session.py templates.
- * CUSTOM strategy intentionally has no default namespace.
  */
 export const DEFAULT_STRATEGY_NAMESPACES: Partial<Record<MemoryStrategyType, string[]>> = {
  SEMANTIC: ['/users/{actorId}/facts'],

src/assets/__tests__/__snapshots__/assets.snapshot.test.ts.snap

@@ -2829,7 +2829,7 @@ file maps to a JSON config file and includes validation constraints as comments.
 - **BuildType**: \`'CodeZip'\` | \`'Container'\`
 - **NetworkMode**: \`'PUBLIC'\` | \`'PRIVATE'\`
 - **RuntimeVersion**: \`'PYTHON_3_12'\` | \`'PYTHON_3_13'\` | \`'NODE_18'\` | \`'NODE_20'\` | \`'NODE_22'\`
-- **MemoryStrategyType**: \`'SEMANTIC'\` | \`'SUMMARIZATION'\` | \`'USER_PREFERENCE'\` | \`'CUSTOM'\`
+- **MemoryStrategyType**: \`'SEMANTIC'\` | \`'SUMMARIZATION'\` | \`'USER_PREFERENCE'\`
 
 ### Supported Frameworks (for template agents)
 

src/assets/agents/AGENTS.md

@@ -63,7 +63,7 @@ file maps to a JSON config file and includes validation constraints as comments.
 - **BuildType**: `'CodeZip'` | `'Container'`
 - **NetworkMode**: `'PUBLIC'` | `'PRIVATE'`
 - **RuntimeVersion**: `'PYTHON_3_12'` | `'PYTHON_3_13'` | `'NODE_18'` | `'NODE_20'` | `'NODE_22'`
-- **MemoryStrategyType**: `'SEMANTIC'` | `'SUMMARIZATION'` | `'USER_PREFERENCE'` | `'CUSTOM'`
+- **MemoryStrategyType**: `'SEMANTIC'` | `'SUMMARIZATION'` | `'USER_PREFERENCE'`
 
 ### Supported Frameworks (for template agents)
 

src/cli/commands/add/__tests__/add-memory.test.ts

@@ -50,6 +50,18 @@ describe('add memory command', () => {
  expect(json.success).toBe(false);
  expect(json.error.includes('INVALID'), `Error: ${json.error}`).toBeTruthy();
  });
+
+ // Issue #235: CUSTOM strategy has been removed
+ it('rejects CUSTOM strategy', async () => {
+ const result = await runCLI(
+ ['add', 'memory', '--name', 'testCustom', '--strategies', 'CUSTOM', '--json'],
+ projectDir
+ );
+ expect(result.exitCode).toBe(1);
+ const json = JSON.parse(result.stdout);
+ expect(json.success).toBe(false);
+ expect(json.error.includes('CUSTOM'), `Error: ${json.error}`).toBeTruthy();
+ });
  });
 
  describe('memory creation', () => {

src/cli/commands/add/__tests__/validate.test.ts

@@ -313,9 +313,51 @@ describe('validate', () => {
  expect(validateAddMemoryOptions(validMemoryOptions)).toEqual({ valid: true });
  // Test all valid strategies
  expect(
- validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION,USER_PREFERENCE,CUSTOM' })
+ validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION,USER_PREFERENCE' })
  ).toEqual({ valid: true });
  });
+
+ // AC23: CUSTOM strategy is not supported (Issue #235)
+ it('rejects CUSTOM strategy', () => {
+ const result = validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'CUSTOM' });
+ expect(result.valid).toBe(false);
+ expect(result.error).toContain('Invalid strategy: CUSTOM');
+ });
+
+ it('rejects CUSTOM even when mixed with valid strategies', () => {
+ const result = validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,CUSTOM' });
+ expect(result.valid).toBe(false);
+ expect(result.error).toContain('Invalid strategy: CUSTOM');
+ });
+
+ // AC24: Each individual valid strategy should pass
+ it('accepts each valid strategy individually', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC' })).toEqual({ valid: true });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SUMMARIZATION' })).toEqual({ valid: true });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ });
+
+ // AC25: Valid strategy combinations should pass
+ it('accepts valid strategy combinations', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION' })).toEqual({
+ valid: true,
+ });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SUMMARIZATION,USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ });
+
+ // AC26: Strategies with whitespace should be handled
+ it('handles strategies with whitespace', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: ' SEMANTIC , SUMMARIZATION ' })).toEqual({
+ valid: true,
+ });
+ });
  });
 
  describe('validateAddIdentityOptions', () => {

src/cli/commands/add/command.tsx

@@ -316,7 +316,7 @@ export function registerAdd(program: Command) {
  .option('--name <name>', 'Memory name [non-interactive]')
  .option(
  '--strategies <types>',
- 'Comma-separated strategies: SEMANTIC, SUMMARIZATION, USER_PREFERENCE, CUSTOM [non-interactive]'
+ 'Comma-separated strategies: SEMANTIC, SUMMARIZATION, USER_PREFERENCE [non-interactive]'
  )
  .option('--expiry <days>', 'Event expiry duration in days (default: 30) [non-interactive]', parseInt)
  .option('--json', 'Output as JSON [non-interactive]')

src/cli/commands/add/validate.ts

@@ -22,7 +22,7 @@ export interface ValidationResult {
 // Constants
 const MEMORY_OPTIONS = ['none', 'shortTerm', 'longAndShortTerm'] as const;
 const OIDC_WELL_KNOWN_SUFFIX = '/.well-known/openid-configuration';
-const VALID_STRATEGIES = ['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE', 'CUSTOM'];
+const VALID_STRATEGIES = ['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE'];
 
 // Agent validation
 export function validateAddAgentOptions(options: AddAgentOptions): ValidationResult {

src/cli/tui/screens/memory/types.ts

@@ -32,7 +32,6 @@ const STRATEGY_DESCRIPTIONS: Record<MemoryStrategyType, string> = {
  SEMANTIC: 'Vector-based semantic search over memories',
  SUMMARIZATION: 'Compress and summarize conversation context',
  USER_PREFERENCE: 'Track and recall user preferences',
- CUSTOM: 'Custom memory strategy implementation',
 };
 
 export const MEMORY_STRATEGY_OPTIONS = MemoryStrategyTypeSchema.options.map(type => ({

src/schema/llm-compacted/agentcore.ts

@@ -27,7 +27,7 @@ type PythonRuntime = 'PYTHON_3_10' | 'PYTHON_3_11' | 'PYTHON_3_12' | 'PYTHON_3_1
 type NodeRuntime = 'NODE_18' | 'NODE_20' | 'NODE_22';
 type RuntimeVersion = PythonRuntime | NodeRuntime;
 type NetworkMode = 'PUBLIC' | 'PRIVATE';
-type MemoryStrategyType = 'SEMANTIC' | 'SUMMARIZATION' | 'USER_PREFERENCE' | 'CUSTOM';
+type MemoryStrategyType = 'SEMANTIC' | 'SUMMARIZATION' | 'USER_PREFERENCE';
 
 // ─────────────────────────────────────────────────────────────────────────────
 // AGENT

src/schema/schemas/primitives/__tests__/memory.test.ts

@@ -0,0 +1,89 @@
+import { DEFAULT_STRATEGY_NAMESPACES, MemoryStrategySchema, MemoryStrategyTypeSchema } from '../memory';
+import { describe, expect, it } from 'vitest';
+
+describe('MemoryStrategyTypeSchema', () => {
+ describe('valid strategy types', () => {
+ it('accepts SEMANTIC', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('SEMANTIC').success).toBe(true);
+ });
+
+ it('accepts SUMMARIZATION', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('SUMMARIZATION').success).toBe(true);
+ });
+
+ it('accepts USER_PREFERENCE', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('USER_PREFERENCE').success).toBe(true);
+ });
+ });
+
+ describe('invalid strategy types', () => {
+ // Issue #235: CUSTOM strategy has been removed
+ it('rejects CUSTOM strategy', () => {
+ const result = MemoryStrategyTypeSchema.safeParse('CUSTOM');
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects arbitrary invalid strategies', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('INVALID').success).toBe(false);
+ expect(MemoryStrategyTypeSchema.safeParse('').success).toBe(false);
+ expect(MemoryStrategyTypeSchema.safeParse('semantic').success).toBe(false); // lowercase
+ });
+ });
+
+ describe('schema options', () => {
+ it('only contains three valid strategies', () => {
+ expect(MemoryStrategyTypeSchema.options).toEqual(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE']);
+ expect(MemoryStrategyTypeSchema.options).not.toContain('CUSTOM');
+ });
+ });
+});
+
+describe('MemoryStrategySchema', () => {
+ it('validates strategy with required type field', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'SEMANTIC' });
+ expect(result.success).toBe(true);
+ });
+
+ it('validates strategy with optional fields', () => {
+ const result = MemoryStrategySchema.safeParse({
+ type: 'SEMANTIC',
+ name: 'myStrategy',
+ description: 'A description',
+ namespaces: ['/users/{actorId}/facts'],
+ });
+ expect(result.success).toBe(true);
+ });
+
+ it('rejects strategy with CUSTOM type', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'CUSTOM' });
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects strategy with invalid type', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'INVALID' });
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects strategy without type', () => {
+ const result = MemoryStrategySchema.safeParse({ name: 'myStrategy' });
+ expect(result.success).toBe(false);
+ });
+});
+
+describe('DEFAULT_STRATEGY_NAMESPACES', () => {
+ it('has default namespaces for SEMANTIC', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.SEMANTIC).toEqual(['/users/{actorId}/facts']);
+ });
+
+ it('has default namespaces for USER_PREFERENCE', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.USER_PREFERENCE).toEqual(['/users/{actorId}/preferences']);
+ });
+
+ it('has default namespaces for SUMMARIZATION', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.SUMMARIZATION).toEqual(['/summaries/{actorId}/{sessionId}']);
+ });
+
+ it('does not have default namespaces for CUSTOM (removed)', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES).not.toHaveProperty('CUSTOM');
+ });
+});

src/schema/schemas/primitives/memory.ts

@@ -10,16 +10,14 @@ import { z } from 'zod';
  * - SEMANTIC → SemanticMemoryStrategy
  * - SUMMARIZATION → SummaryMemoryStrategy (note: CloudFormation uses "Summary")
  * - USER_PREFERENCE → UserPreferenceMemoryStrategy
- * - CUSTOM → CustomMemoryStrategy
  * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-bedrockagentcore-memory-memorystrategy.html
  */
-export const MemoryStrategyTypeSchema = z.enum(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE', 'CUSTOM']);
+export const MemoryStrategyTypeSchema = z.enum(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE']);
 export type MemoryStrategyType = z.infer<typeof MemoryStrategyTypeSchema>;
 
 /**
  * Default namespaces for each memory strategy type.
  * These match the patterns generated in CLI session.py templates.
- * CUSTOM strategy intentionally has no default namespace.
  */
 export const DEFAULT_STRATEGY_NAMESPACES: Partial<Record<MemoryStrategyType, string[]>> = {
  SEMANTIC: ['/users/{actorId}/facts'],

src/assets/__tests__/__snapshots__/assets.snapshot.test.ts.snap

@@ -2829,7 +2829,7 @@ file maps to a JSON config file and includes validation constraints as comments.
 - **BuildType**: \`'CodeZip'\` | \`'Container'\`
 - **NetworkMode**: \`'PUBLIC'\` | \`'PRIVATE'\`
 - **RuntimeVersion**: \`'PYTHON_3_12'\` | \`'PYTHON_3_13'\` | \`'NODE_18'\` | \`'NODE_20'\` | \`'NODE_22'\`
-- **MemoryStrategyType**: \`'SEMANTIC'\` | \`'SUMMARIZATION'\` | \`'USER_PREFERENCE'\` | \`'CUSTOM'\`
+- **MemoryStrategyType**: \`'SEMANTIC'\` | \`'SUMMARIZATION'\` | \`'USER_PREFERENCE'\`
 
 ### Supported Frameworks (for template agents)
 

src/assets/agents/AGENTS.md

@@ -63,7 +63,7 @@ file maps to a JSON config file and includes validation constraints as comments.
 - **BuildType**: `'CodeZip'` | `'Container'`
 - **NetworkMode**: `'PUBLIC'` | `'PRIVATE'`
 - **RuntimeVersion**: `'PYTHON_3_12'` | `'PYTHON_3_13'` | `'NODE_18'` | `'NODE_20'` | `'NODE_22'`
-- **MemoryStrategyType**: `'SEMANTIC'` | `'SUMMARIZATION'` | `'USER_PREFERENCE'` | `'CUSTOM'`
+- **MemoryStrategyType**: `'SEMANTIC'` | `'SUMMARIZATION'` | `'USER_PREFERENCE'`
 
 ### Supported Frameworks (for template agents)
 

src/cli/commands/add/__tests__/add-memory.test.ts

@@ -50,6 +50,18 @@ describe('add memory command', () => {
  expect(json.success).toBe(false);
  expect(json.error.includes('INVALID'), `Error: ${json.error}`).toBeTruthy();
  });
+
+ // Issue #235: CUSTOM strategy has been removed
+ it('rejects CUSTOM strategy', async () => {
+ const result = await runCLI(
+ ['add', 'memory', '--name', 'testCustom', '--strategies', 'CUSTOM', '--json'],
+ projectDir
+ );
+ expect(result.exitCode).toBe(1);
+ const json = JSON.parse(result.stdout);
+ expect(json.success).toBe(false);
+ expect(json.error.includes('CUSTOM'), `Error: ${json.error}`).toBeTruthy();
+ });
  });
 
  describe('memory creation', () => {

src/cli/commands/add/__tests__/validate.test.ts

@@ -313,9 +313,51 @@ describe('validate', () => {
  expect(validateAddMemoryOptions(validMemoryOptions)).toEqual({ valid: true });
  // Test all valid strategies
  expect(
- validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION,USER_PREFERENCE,CUSTOM' })
+ validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION,USER_PREFERENCE' })
  ).toEqual({ valid: true });
  });
+
+ // AC23: CUSTOM strategy is not supported (Issue #235)
+ it('rejects CUSTOM strategy', () => {
+ const result = validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'CUSTOM' });
+ expect(result.valid).toBe(false);
+ expect(result.error).toContain('Invalid strategy: CUSTOM');
+ });
+
+ it('rejects CUSTOM even when mixed with valid strategies', () => {
+ const result = validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,CUSTOM' });
+ expect(result.valid).toBe(false);
+ expect(result.error).toContain('Invalid strategy: CUSTOM');
+ });
+
+ // AC24: Each individual valid strategy should pass
+ it('accepts each valid strategy individually', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC' })).toEqual({ valid: true });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SUMMARIZATION' })).toEqual({ valid: true });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ });
+
+ // AC25: Valid strategy combinations should pass
+ it('accepts valid strategy combinations', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION' })).toEqual({
+ valid: true,
+ });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SUMMARIZATION,USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ });
+
+ // AC26: Strategies with whitespace should be handled
+ it('handles strategies with whitespace', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: ' SEMANTIC , SUMMARIZATION ' })).toEqual({
+ valid: true,
+ });
+ });
  });
 
  describe('validateAddIdentityOptions', () => {

src/cli/commands/add/command.tsx

@@ -316,7 +316,7 @@ export function registerAdd(program: Command) {
  .option('--name <name>', 'Memory name [non-interactive]')
  .option(
  '--strategies <types>',
- 'Comma-separated strategies: SEMANTIC, SUMMARIZATION, USER_PREFERENCE, CUSTOM [non-interactive]'
+ 'Comma-separated strategies: SEMANTIC, SUMMARIZATION, USER_PREFERENCE [non-interactive]'
  )
  .option('--expiry <days>', 'Event expiry duration in days (default: 30) [non-interactive]', parseInt)
  .option('--json', 'Output as JSON [non-interactive]')

src/cli/commands/add/validate.ts

@@ -22,7 +22,7 @@ export interface ValidationResult {
 // Constants
 const MEMORY_OPTIONS = ['none', 'shortTerm', 'longAndShortTerm'] as const;
 const OIDC_WELL_KNOWN_SUFFIX = '/.well-known/openid-configuration';
-const VALID_STRATEGIES = ['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE', 'CUSTOM'];
+const VALID_STRATEGIES = ['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE'];
 
 // Agent validation
 export function validateAddAgentOptions(options: AddAgentOptions): ValidationResult {

src/cli/tui/screens/memory/types.ts

@@ -32,7 +32,6 @@ const STRATEGY_DESCRIPTIONS: Record<MemoryStrategyType, string> = {
  SEMANTIC: 'Vector-based semantic search over memories',
  SUMMARIZATION: 'Compress and summarize conversation context',
  USER_PREFERENCE: 'Track and recall user preferences',
- CUSTOM: 'Custom memory strategy implementation',
 };
 
 export const MEMORY_STRATEGY_OPTIONS = MemoryStrategyTypeSchema.options.map(type => ({

src/schema/llm-compacted/agentcore.ts

@@ -27,7 +27,7 @@ type PythonRuntime = 'PYTHON_3_10' | 'PYTHON_3_11' | 'PYTHON_3_12' | 'PYTHON_3_1
 type NodeRuntime = 'NODE_18' | 'NODE_20' | 'NODE_22';
 type RuntimeVersion = PythonRuntime | NodeRuntime;
 type NetworkMode = 'PUBLIC' | 'PRIVATE';
-type MemoryStrategyType = 'SEMANTIC' | 'SUMMARIZATION' | 'USER_PREFERENCE' | 'CUSTOM';
+type MemoryStrategyType = 'SEMANTIC' | 'SUMMARIZATION' | 'USER_PREFERENCE';
 
 // ─────────────────────────────────────────────────────────────────────────────
 // AGENT

src/schema/schemas/primitives/__tests__/memory.test.ts

@@ -0,0 +1,89 @@
+import { DEFAULT_STRATEGY_NAMESPACES, MemoryStrategySchema, MemoryStrategyTypeSchema } from '../memory';
+import { describe, expect, it } from 'vitest';
+
+describe('MemoryStrategyTypeSchema', () => {
+ describe('valid strategy types', () => {
+ it('accepts SEMANTIC', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('SEMANTIC').success).toBe(true);
+ });
+
+ it('accepts SUMMARIZATION', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('SUMMARIZATION').success).toBe(true);
+ });
+
+ it('accepts USER_PREFERENCE', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('USER_PREFERENCE').success).toBe(true);
+ });
+ });
+
+ describe('invalid strategy types', () => {
+ // Issue #235: CUSTOM strategy has been removed
+ it('rejects CUSTOM strategy', () => {
+ const result = MemoryStrategyTypeSchema.safeParse('CUSTOM');
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects arbitrary invalid strategies', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('INVALID').success).toBe(false);
+ expect(MemoryStrategyTypeSchema.safeParse('').success).toBe(false);
+ expect(MemoryStrategyTypeSchema.safeParse('semantic').success).toBe(false); // lowercase
+ });
+ });
+
+ describe('schema options', () => {
+ it('only contains three valid strategies', () => {
+ expect(MemoryStrategyTypeSchema.options).toEqual(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE']);
+ expect(MemoryStrategyTypeSchema.options).not.toContain('CUSTOM');
+ });
+ });
+});
+
+describe('MemoryStrategySchema', () => {
+ it('validates strategy with required type field', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'SEMANTIC' });
+ expect(result.success).toBe(true);
+ });
+
+ it('validates strategy with optional fields', () => {
+ const result = MemoryStrategySchema.safeParse({
+ type: 'SEMANTIC',
+ name: 'myStrategy',
+ description: 'A description',
+ namespaces: ['/users/{actorId}/facts'],
+ });
+ expect(result.success).toBe(true);
+ });
+
+ it('rejects strategy with CUSTOM type', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'CUSTOM' });
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects strategy with invalid type', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'INVALID' });
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects strategy without type', () => {
+ const result = MemoryStrategySchema.safeParse({ name: 'myStrategy' });
+ expect(result.success).toBe(false);
+ });
+});
+
+describe('DEFAULT_STRATEGY_NAMESPACES', () => {
+ it('has default namespaces for SEMANTIC', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.SEMANTIC).toEqual(['/users/{actorId}/facts']);
+ });
+
+ it('has default namespaces for USER_PREFERENCE', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.USER_PREFERENCE).toEqual(['/users/{actorId}/preferences']);
+ });
+
+ it('has default namespaces for SUMMARIZATION', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.SUMMARIZATION).toEqual(['/summaries/{actorId}/{sessionId}']);
+ });
+
+ it('does not have default namespaces for CUSTOM (removed)', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES).not.toHaveProperty('CUSTOM');
+ });
+});

src/schema/schemas/primitives/memory.ts

@@ -10,16 +10,14 @@ import { z } from 'zod';
  * - SEMANTIC → SemanticMemoryStrategy
  * - SUMMARIZATION → SummaryMemoryStrategy (note: CloudFormation uses "Summary")
  * - USER_PREFERENCE → UserPreferenceMemoryStrategy
- * - CUSTOM → CustomMemoryStrategy
  * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-bedrockagentcore-memory-memorystrategy.html
  */
-export const MemoryStrategyTypeSchema = z.enum(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE', 'CUSTOM']);
+export const MemoryStrategyTypeSchema = z.enum(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE']);
 export type MemoryStrategyType = z.infer<typeof MemoryStrategyTypeSchema>;
 
 /**
  * Default namespaces for each memory strategy type.
  * These match the patterns generated in CLI session.py templates.
- * CUSTOM strategy intentionally has no default namespace.
  */
 export const DEFAULT_STRATEGY_NAMESPACES: Partial<Record<MemoryStrategyType, string[]>> = {
  SEMANTIC: ['/users/{actorId}/facts'],

src/assets/__tests__/__snapshots__/assets.snapshot.test.ts.snap

@@ -2829,7 +2829,7 @@ file maps to a JSON config file and includes validation constraints as comments.
 - **BuildType**: \`'CodeZip'\` | \`'Container'\`
 - **NetworkMode**: \`'PUBLIC'\` | \`'PRIVATE'\`
 - **RuntimeVersion**: \`'PYTHON_3_12'\` | \`'PYTHON_3_13'\` | \`'NODE_18'\` | \`'NODE_20'\` | \`'NODE_22'\`
-- **MemoryStrategyType**: \`'SEMANTIC'\` | \`'SUMMARIZATION'\` | \`'USER_PREFERENCE'\` | \`'CUSTOM'\`
+- **MemoryStrategyType**: \`'SEMANTIC'\` | \`'SUMMARIZATION'\` | \`'USER_PREFERENCE'\`
 
 ### Supported Frameworks (for template agents)
 

src/assets/agents/AGENTS.md

@@ -63,7 +63,7 @@ file maps to a JSON config file and includes validation constraints as comments.
 - **BuildType**: `'CodeZip'` | `'Container'`
 - **NetworkMode**: `'PUBLIC'` | `'PRIVATE'`
 - **RuntimeVersion**: `'PYTHON_3_12'` | `'PYTHON_3_13'` | `'NODE_18'` | `'NODE_20'` | `'NODE_22'`
-- **MemoryStrategyType**: `'SEMANTIC'` | `'SUMMARIZATION'` | `'USER_PREFERENCE'` | `'CUSTOM'`
+- **MemoryStrategyType**: `'SEMANTIC'` | `'SUMMARIZATION'` | `'USER_PREFERENCE'`
 
 ### Supported Frameworks (for template agents)
 

src/cli/commands/add/__tests__/add-memory.test.ts

@@ -50,6 +50,18 @@ describe('add memory command', () => {
  expect(json.success).toBe(false);
  expect(json.error.includes('INVALID'), `Error: ${json.error}`).toBeTruthy();
  });
+
+ // Issue #235: CUSTOM strategy has been removed
+ it('rejects CUSTOM strategy', async () => {
+ const result = await runCLI(
+ ['add', 'memory', '--name', 'testCustom', '--strategies', 'CUSTOM', '--json'],
+ projectDir
+ );
+ expect(result.exitCode).toBe(1);
+ const json = JSON.parse(result.stdout);
+ expect(json.success).toBe(false);
+ expect(json.error.includes('CUSTOM'), `Error: ${json.error}`).toBeTruthy();
+ });
  });
 
  describe('memory creation', () => {

src/cli/commands/add/__tests__/validate.test.ts

@@ -313,9 +313,51 @@ describe('validate', () => {
  expect(validateAddMemoryOptions(validMemoryOptions)).toEqual({ valid: true });
  // Test all valid strategies
  expect(
- validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION,USER_PREFERENCE,CUSTOM' })
+ validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION,USER_PREFERENCE' })
  ).toEqual({ valid: true });
  });
+
+ // AC23: CUSTOM strategy is not supported (Issue #235)
+ it('rejects CUSTOM strategy', () => {
+ const result = validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'CUSTOM' });
+ expect(result.valid).toBe(false);
+ expect(result.error).toContain('Invalid strategy: CUSTOM');
+ });
+
+ it('rejects CUSTOM even when mixed with valid strategies', () => {
+ const result = validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,CUSTOM' });
+ expect(result.valid).toBe(false);
+ expect(result.error).toContain('Invalid strategy: CUSTOM');
+ });
+
+ // AC24: Each individual valid strategy should pass
+ it('accepts each valid strategy individually', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC' })).toEqual({ valid: true });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SUMMARIZATION' })).toEqual({ valid: true });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ });
+
+ // AC25: Valid strategy combinations should pass
+ it('accepts valid strategy combinations', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION' })).toEqual({
+ valid: true,
+ });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SUMMARIZATION,USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ });
+
+ // AC26: Strategies with whitespace should be handled
+ it('handles strategies with whitespace', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: ' SEMANTIC , SUMMARIZATION ' })).toEqual({
+ valid: true,
+ });
+ });
  });
 
  describe('validateAddIdentityOptions', () => {

src/cli/commands/add/command.tsx

@@ -316,7 +316,7 @@ export function registerAdd(program: Command) {
  .option('--name <name>', 'Memory name [non-interactive]')
  .option(
  '--strategies <types>',
- 'Comma-separated strategies: SEMANTIC, SUMMARIZATION, USER_PREFERENCE, CUSTOM [non-interactive]'
+ 'Comma-separated strategies: SEMANTIC, SUMMARIZATION, USER_PREFERENCE [non-interactive]'
  )
  .option('--expiry <days>', 'Event expiry duration in days (default: 30) [non-interactive]', parseInt)
  .option('--json', 'Output as JSON [non-interactive]')

src/cli/commands/add/validate.ts

@@ -22,7 +22,7 @@ export interface ValidationResult {
 // Constants
 const MEMORY_OPTIONS = ['none', 'shortTerm', 'longAndShortTerm'] as const;
 const OIDC_WELL_KNOWN_SUFFIX = '/.well-known/openid-configuration';
-const VALID_STRATEGIES = ['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE', 'CUSTOM'];
+const VALID_STRATEGIES = ['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE'];
 
 // Agent validation
 export function validateAddAgentOptions(options: AddAgentOptions): ValidationResult {

src/cli/tui/screens/memory/types.ts

@@ -32,7 +32,6 @@ const STRATEGY_DESCRIPTIONS: Record<MemoryStrategyType, string> = {
  SEMANTIC: 'Vector-based semantic search over memories',
  SUMMARIZATION: 'Compress and summarize conversation context',
  USER_PREFERENCE: 'Track and recall user preferences',
- CUSTOM: 'Custom memory strategy implementation',
 };
 
 export const MEMORY_STRATEGY_OPTIONS = MemoryStrategyTypeSchema.options.map(type => ({

src/schema/llm-compacted/agentcore.ts

@@ -27,7 +27,7 @@ type PythonRuntime = 'PYTHON_3_10' | 'PYTHON_3_11' | 'PYTHON_3_12' | 'PYTHON_3_1
 type NodeRuntime = 'NODE_18' | 'NODE_20' | 'NODE_22';
 type RuntimeVersion = PythonRuntime | NodeRuntime;
 type NetworkMode = 'PUBLIC' | 'PRIVATE';
-type MemoryStrategyType = 'SEMANTIC' | 'SUMMARIZATION' | 'USER_PREFERENCE' | 'CUSTOM';
+type MemoryStrategyType = 'SEMANTIC' | 'SUMMARIZATION' | 'USER_PREFERENCE';
 
 // ─────────────────────────────────────────────────────────────────────────────
 // AGENT

src/schema/schemas/primitives/__tests__/memory.test.ts

@@ -0,0 +1,89 @@
+import { DEFAULT_STRATEGY_NAMESPACES, MemoryStrategySchema, MemoryStrategyTypeSchema } from '../memory';
+import { describe, expect, it } from 'vitest';
+
+describe('MemoryStrategyTypeSchema', () => {
+ describe('valid strategy types', () => {
+ it('accepts SEMANTIC', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('SEMANTIC').success).toBe(true);
+ });
+
+ it('accepts SUMMARIZATION', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('SUMMARIZATION').success).toBe(true);
+ });
+
+ it('accepts USER_PREFERENCE', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('USER_PREFERENCE').success).toBe(true);
+ });
+ });
+
+ describe('invalid strategy types', () => {
+ // Issue #235: CUSTOM strategy has been removed
+ it('rejects CUSTOM strategy', () => {
+ const result = MemoryStrategyTypeSchema.safeParse('CUSTOM');
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects arbitrary invalid strategies', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('INVALID').success).toBe(false);
+ expect(MemoryStrategyTypeSchema.safeParse('').success).toBe(false);
+ expect(MemoryStrategyTypeSchema.safeParse('semantic').success).toBe(false); // lowercase
+ });
+ });
+
+ describe('schema options', () => {
+ it('only contains three valid strategies', () => {
+ expect(MemoryStrategyTypeSchema.options).toEqual(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE']);
+ expect(MemoryStrategyTypeSchema.options).not.toContain('CUSTOM');
+ });
+ });
+});
+
+describe('MemoryStrategySchema', () => {
+ it('validates strategy with required type field', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'SEMANTIC' });
+ expect(result.success).toBe(true);
+ });
+
+ it('validates strategy with optional fields', () => {
+ const result = MemoryStrategySchema.safeParse({
+ type: 'SEMANTIC',
+ name: 'myStrategy',
+ description: 'A description',
+ namespaces: ['/users/{actorId}/facts'],
+ });
+ expect(result.success).toBe(true);
+ });
+
+ it('rejects strategy with CUSTOM type', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'CUSTOM' });
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects strategy with invalid type', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'INVALID' });
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects strategy without type', () => {
+ const result = MemoryStrategySchema.safeParse({ name: 'myStrategy' });
+ expect(result.success).toBe(false);
+ });
+});
+
+describe('DEFAULT_STRATEGY_NAMESPACES', () => {
+ it('has default namespaces for SEMANTIC', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.SEMANTIC).toEqual(['/users/{actorId}/facts']);
+ });
+
+ it('has default namespaces for USER_PREFERENCE', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.USER_PREFERENCE).toEqual(['/users/{actorId}/preferences']);
+ });
+
+ it('has default namespaces for SUMMARIZATION', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.SUMMARIZATION).toEqual(['/summaries/{actorId}/{sessionId}']);
+ });
+
+ it('does not have default namespaces for CUSTOM (removed)', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES).not.toHaveProperty('CUSTOM');
+ });
+});

src/schema/schemas/primitives/memory.ts

@@ -10,16 +10,14 @@ import { z } from 'zod';
  * - SEMANTIC → SemanticMemoryStrategy
  * - SUMMARIZATION → SummaryMemoryStrategy (note: CloudFormation uses "Summary")
  * - USER_PREFERENCE → UserPreferenceMemoryStrategy
- * - CUSTOM → CustomMemoryStrategy
  * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-bedrockagentcore-memory-memorystrategy.html
  */
-export const MemoryStrategyTypeSchema = z.enum(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE', 'CUSTOM']);
+export const MemoryStrategyTypeSchema = z.enum(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE']);
 export type MemoryStrategyType = z.infer<typeof MemoryStrategyTypeSchema>;
 
 /**
  * Default namespaces for each memory strategy type.
  * These match the patterns generated in CLI session.py templates.
- * CUSTOM strategy intentionally has no default namespace.
  */
 export const DEFAULT_STRATEGY_NAMESPACES: Partial<Record<MemoryStrategyType, string[]>> = {
  SEMANTIC: ['/users/{actorId}/facts'],

src/assets/__tests__/__snapshots__/assets.snapshot.test.ts.snap

@@ -2829,7 +2829,7 @@ file maps to a JSON config file and includes validation constraints as comments.
 - **BuildType**: \`'CodeZip'\` | \`'Container'\`
 - **NetworkMode**: \`'PUBLIC'\` | \`'PRIVATE'\`
 - **RuntimeVersion**: \`'PYTHON_3_12'\` | \`'PYTHON_3_13'\` | \`'NODE_18'\` | \`'NODE_20'\` | \`'NODE_22'\`
-- **MemoryStrategyType**: \`'SEMANTIC'\` | \`'SUMMARIZATION'\` | \`'USER_PREFERENCE'\` | \`'CUSTOM'\`
+- **MemoryStrategyType**: \`'SEMANTIC'\` | \`'SUMMARIZATION'\` | \`'USER_PREFERENCE'\`
 
 ### Supported Frameworks (for template agents)
 

src/assets/agents/AGENTS.md

@@ -63,7 +63,7 @@ file maps to a JSON config file and includes validation constraints as comments.
 - **BuildType**: `'CodeZip'` | `'Container'`
 - **NetworkMode**: `'PUBLIC'` | `'PRIVATE'`
 - **RuntimeVersion**: `'PYTHON_3_12'` | `'PYTHON_3_13'` | `'NODE_18'` | `'NODE_20'` | `'NODE_22'`
-- **MemoryStrategyType**: `'SEMANTIC'` | `'SUMMARIZATION'` | `'USER_PREFERENCE'` | `'CUSTOM'`
+- **MemoryStrategyType**: `'SEMANTIC'` | `'SUMMARIZATION'` | `'USER_PREFERENCE'`
 
 ### Supported Frameworks (for template agents)
 

src/cli/commands/add/__tests__/add-memory.test.ts

@@ -50,6 +50,18 @@ describe('add memory command', () => {
  expect(json.success).toBe(false);
  expect(json.error.includes('INVALID'), `Error: ${json.error}`).toBeTruthy();
  });
+
+ // Issue #235: CUSTOM strategy has been removed
+ it('rejects CUSTOM strategy', async () => {
+ const result = await runCLI(
+ ['add', 'memory', '--name', 'testCustom', '--strategies', 'CUSTOM', '--json'],
+ projectDir
+ );
+ expect(result.exitCode).toBe(1);
+ const json = JSON.parse(result.stdout);
+ expect(json.success).toBe(false);
+ expect(json.error.includes('CUSTOM'), `Error: ${json.error}`).toBeTruthy();
+ });
  });
 
  describe('memory creation', () => {

src/cli/commands/add/__tests__/validate.test.ts

@@ -313,9 +313,51 @@ describe('validate', () => {
  expect(validateAddMemoryOptions(validMemoryOptions)).toEqual({ valid: true });
  // Test all valid strategies
  expect(
- validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION,USER_PREFERENCE,CUSTOM' })
+ validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION,USER_PREFERENCE' })
  ).toEqual({ valid: true });
  });
+
+ // AC23: CUSTOM strategy is not supported (Issue #235)
+ it('rejects CUSTOM strategy', () => {
+ const result = validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'CUSTOM' });
+ expect(result.valid).toBe(false);
+ expect(result.error).toContain('Invalid strategy: CUSTOM');
+ });
+
+ it('rejects CUSTOM even when mixed with valid strategies', () => {
+ const result = validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,CUSTOM' });
+ expect(result.valid).toBe(false);
+ expect(result.error).toContain('Invalid strategy: CUSTOM');
+ });
+
+ // AC24: Each individual valid strategy should pass
+ it('accepts each valid strategy individually', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC' })).toEqual({ valid: true });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SUMMARIZATION' })).toEqual({ valid: true });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ });
+
+ // AC25: Valid strategy combinations should pass
+ it('accepts valid strategy combinations', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION' })).toEqual({
+ valid: true,
+ });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SUMMARIZATION,USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ });
+
+ // AC26: Strategies with whitespace should be handled
+ it('handles strategies with whitespace', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: ' SEMANTIC , SUMMARIZATION ' })).toEqual({
+ valid: true,
+ });
+ });
  });
 
  describe('validateAddIdentityOptions', () => {

src/cli/commands/add/command.tsx

@@ -316,7 +316,7 @@ export function registerAdd(program: Command) {
  .option('--name <name>', 'Memory name [non-interactive]')
  .option(
  '--strategies <types>',
- 'Comma-separated strategies: SEMANTIC, SUMMARIZATION, USER_PREFERENCE, CUSTOM [non-interactive]'
+ 'Comma-separated strategies: SEMANTIC, SUMMARIZATION, USER_PREFERENCE [non-interactive]'
  )
  .option('--expiry <days>', 'Event expiry duration in days (default: 30) [non-interactive]', parseInt)
  .option('--json', 'Output as JSON [non-interactive]')

src/cli/commands/add/validate.ts

@@ -22,7 +22,7 @@ export interface ValidationResult {
 // Constants
 const MEMORY_OPTIONS = ['none', 'shortTerm', 'longAndShortTerm'] as const;
 const OIDC_WELL_KNOWN_SUFFIX = '/.well-known/openid-configuration';
-const VALID_STRATEGIES = ['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE', 'CUSTOM'];
+const VALID_STRATEGIES = ['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE'];
 
 // Agent validation
 export function validateAddAgentOptions(options: AddAgentOptions): ValidationResult {

src/cli/tui/screens/memory/types.ts

@@ -32,7 +32,6 @@ const STRATEGY_DESCRIPTIONS: Record<MemoryStrategyType, string> = {
  SEMANTIC: 'Vector-based semantic search over memories',
  SUMMARIZATION: 'Compress and summarize conversation context',
  USER_PREFERENCE: 'Track and recall user preferences',
- CUSTOM: 'Custom memory strategy implementation',
 };
 
 export const MEMORY_STRATEGY_OPTIONS = MemoryStrategyTypeSchema.options.map(type => ({

src/schema/llm-compacted/agentcore.ts

@@ -27,7 +27,7 @@ type PythonRuntime = 'PYTHON_3_10' | 'PYTHON_3_11' | 'PYTHON_3_12' | 'PYTHON_3_1
 type NodeRuntime = 'NODE_18' | 'NODE_20' | 'NODE_22';
 type RuntimeVersion = PythonRuntime | NodeRuntime;
 type NetworkMode = 'PUBLIC' | 'PRIVATE';
-type MemoryStrategyType = 'SEMANTIC' | 'SUMMARIZATION' | 'USER_PREFERENCE' | 'CUSTOM';
+type MemoryStrategyType = 'SEMANTIC' | 'SUMMARIZATION' | 'USER_PREFERENCE';
 
 // ─────────────────────────────────────────────────────────────────────────────
 // AGENT

src/schema/schemas/primitives/__tests__/memory.test.ts

@@ -0,0 +1,89 @@
+import { DEFAULT_STRATEGY_NAMESPACES, MemoryStrategySchema, MemoryStrategyTypeSchema } from '../memory';
+import { describe, expect, it } from 'vitest';
+
+describe('MemoryStrategyTypeSchema', () => {
+ describe('valid strategy types', () => {
+ it('accepts SEMANTIC', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('SEMANTIC').success).toBe(true);
+ });
+
+ it('accepts SUMMARIZATION', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('SUMMARIZATION').success).toBe(true);
+ });
+
+ it('accepts USER_PREFERENCE', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('USER_PREFERENCE').success).toBe(true);
+ });
+ });
+
+ describe('invalid strategy types', () => {
+ // Issue #235: CUSTOM strategy has been removed
+ it('rejects CUSTOM strategy', () => {
+ const result = MemoryStrategyTypeSchema.safeParse('CUSTOM');
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects arbitrary invalid strategies', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('INVALID').success).toBe(false);
+ expect(MemoryStrategyTypeSchema.safeParse('').success).toBe(false);
+ expect(MemoryStrategyTypeSchema.safeParse('semantic').success).toBe(false); // lowercase
+ });
+ });
+
+ describe('schema options', () => {
+ it('only contains three valid strategies', () => {
+ expect(MemoryStrategyTypeSchema.options).toEqual(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE']);
+ expect(MemoryStrategyTypeSchema.options).not.toContain('CUSTOM');
+ });
+ });
+});
+
+describe('MemoryStrategySchema', () => {
+ it('validates strategy with required type field', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'SEMANTIC' });
+ expect(result.success).toBe(true);
+ });
+
+ it('validates strategy with optional fields', () => {
+ const result = MemoryStrategySchema.safeParse({
+ type: 'SEMANTIC',
+ name: 'myStrategy',
+ description: 'A description',
+ namespaces: ['/users/{actorId}/facts'],
+ });
+ expect(result.success).toBe(true);
+ });
+
+ it('rejects strategy with CUSTOM type', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'CUSTOM' });
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects strategy with invalid type', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'INVALID' });
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects strategy without type', () => {
+ const result = MemoryStrategySchema.safeParse({ name: 'myStrategy' });
+ expect(result.success).toBe(false);
+ });
+});
+
+describe('DEFAULT_STRATEGY_NAMESPACES', () => {
+ it('has default namespaces for SEMANTIC', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.SEMANTIC).toEqual(['/users/{actorId}/facts']);
+ });
+
+ it('has default namespaces for USER_PREFERENCE', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.USER_PREFERENCE).toEqual(['/users/{actorId}/preferences']);
+ });
+
+ it('has default namespaces for SUMMARIZATION', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.SUMMARIZATION).toEqual(['/summaries/{actorId}/{sessionId}']);
+ });
+
+ it('does not have default namespaces for CUSTOM (removed)', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES).not.toHaveProperty('CUSTOM');
+ });
+});

src/schema/schemas/primitives/memory.ts

@@ -10,16 +10,14 @@ import { z } from 'zod';
  * - SEMANTIC → SemanticMemoryStrategy
  * - SUMMARIZATION → SummaryMemoryStrategy (note: CloudFormation uses "Summary")
  * - USER_PREFERENCE → UserPreferenceMemoryStrategy
- * - CUSTOM → CustomMemoryStrategy
  * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-bedrockagentcore-memory-memorystrategy.html
  */
-export const MemoryStrategyTypeSchema = z.enum(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE', 'CUSTOM']);
+export const MemoryStrategyTypeSchema = z.enum(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE']);
 export type MemoryStrategyType = z.infer<typeof MemoryStrategyTypeSchema>;
 
 /**
  * Default namespaces for each memory strategy type.
  * These match the patterns generated in CLI session.py templates.
- * CUSTOM strategy intentionally has no default namespace.
  */
 export const DEFAULT_STRATEGY_NAMESPACES: Partial<Record<MemoryStrategyType, string[]>> = {
  SEMANTIC: ['/users/{actorId}/facts'],

src/assets/__tests__/__snapshots__/assets.snapshot.test.ts.snap

@@ -2829,7 +2829,7 @@ file maps to a JSON config file and includes validation constraints as comments.
 - **BuildType**: \`'CodeZip'\` | \`'Container'\`
 - **NetworkMode**: \`'PUBLIC'\` | \`'PRIVATE'\`
 - **RuntimeVersion**: \`'PYTHON_3_12'\` | \`'PYTHON_3_13'\` | \`'NODE_18'\` | \`'NODE_20'\` | \`'NODE_22'\`
-- **MemoryStrategyType**: \`'SEMANTIC'\` | \`'SUMMARIZATION'\` | \`'USER_PREFERENCE'\` | \`'CUSTOM'\`
+- **MemoryStrategyType**: \`'SEMANTIC'\` | \`'SUMMARIZATION'\` | \`'USER_PREFERENCE'\`
 
 ### Supported Frameworks (for template agents)
 

src/assets/agents/AGENTS.md

@@ -63,7 +63,7 @@ file maps to a JSON config file and includes validation constraints as comments.
 - **BuildType**: `'CodeZip'` | `'Container'`
 - **NetworkMode**: `'PUBLIC'` | `'PRIVATE'`
 - **RuntimeVersion**: `'PYTHON_3_12'` | `'PYTHON_3_13'` | `'NODE_18'` | `'NODE_20'` | `'NODE_22'`
-- **MemoryStrategyType**: `'SEMANTIC'` | `'SUMMARIZATION'` | `'USER_PREFERENCE'` | `'CUSTOM'`
+- **MemoryStrategyType**: `'SEMANTIC'` | `'SUMMARIZATION'` | `'USER_PREFERENCE'`
 
 ### Supported Frameworks (for template agents)
 

src/cli/commands/add/__tests__/add-memory.test.ts

@@ -50,6 +50,18 @@ describe('add memory command', () => {
  expect(json.success).toBe(false);
  expect(json.error.includes('INVALID'), `Error: ${json.error}`).toBeTruthy();
  });
+
+ // Issue #235: CUSTOM strategy has been removed
+ it('rejects CUSTOM strategy', async () => {
+ const result = await runCLI(
+ ['add', 'memory', '--name', 'testCustom', '--strategies', 'CUSTOM', '--json'],
+ projectDir
+ );
+ expect(result.exitCode).toBe(1);
+ const json = JSON.parse(result.stdout);
+ expect(json.success).toBe(false);
+ expect(json.error.includes('CUSTOM'), `Error: ${json.error}`).toBeTruthy();
+ });
  });
 
  describe('memory creation', () => {

src/cli/commands/add/__tests__/validate.test.ts

@@ -313,9 +313,51 @@ describe('validate', () => {
  expect(validateAddMemoryOptions(validMemoryOptions)).toEqual({ valid: true });
  // Test all valid strategies
  expect(
- validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION,USER_PREFERENCE,CUSTOM' })
+ validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION,USER_PREFERENCE' })
  ).toEqual({ valid: true });
  });
+
+ // AC23: CUSTOM strategy is not supported (Issue #235)
+ it('rejects CUSTOM strategy', () => {
+ const result = validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'CUSTOM' });
+ expect(result.valid).toBe(false);
+ expect(result.error).toContain('Invalid strategy: CUSTOM');
+ });
+
+ it('rejects CUSTOM even when mixed with valid strategies', () => {
+ const result = validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,CUSTOM' });
+ expect(result.valid).toBe(false);
+ expect(result.error).toContain('Invalid strategy: CUSTOM');
+ });
+
+ // AC24: Each individual valid strategy should pass
+ it('accepts each valid strategy individually', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC' })).toEqual({ valid: true });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SUMMARIZATION' })).toEqual({ valid: true });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ });
+
+ // AC25: Valid strategy combinations should pass
+ it('accepts valid strategy combinations', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION' })).toEqual({
+ valid: true,
+ });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SUMMARIZATION,USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ });
+
+ // AC26: Strategies with whitespace should be handled
+ it('handles strategies with whitespace', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: ' SEMANTIC , SUMMARIZATION ' })).toEqual({
+ valid: true,
+ });
+ });
  });
 
  describe('validateAddIdentityOptions', () => {

src/cli/commands/add/command.tsx

@@ -316,7 +316,7 @@ export function registerAdd(program: Command) {
  .option('--name <name>', 'Memory name [non-interactive]')
  .option(
  '--strategies <types>',
- 'Comma-separated strategies: SEMANTIC, SUMMARIZATION, USER_PREFERENCE, CUSTOM [non-interactive]'
+ 'Comma-separated strategies: SEMANTIC, SUMMARIZATION, USER_PREFERENCE [non-interactive]'
  )
  .option('--expiry <days>', 'Event expiry duration in days (default: 30) [non-interactive]', parseInt)
  .option('--json', 'Output as JSON [non-interactive]')

src/cli/commands/add/validate.ts

@@ -22,7 +22,7 @@ export interface ValidationResult {
 // Constants
 const MEMORY_OPTIONS = ['none', 'shortTerm', 'longAndShortTerm'] as const;
 const OIDC_WELL_KNOWN_SUFFIX = '/.well-known/openid-configuration';
-const VALID_STRATEGIES = ['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE', 'CUSTOM'];
+const VALID_STRATEGIES = ['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE'];
 
 // Agent validation
 export function validateAddAgentOptions(options: AddAgentOptions): ValidationResult {

src/cli/tui/screens/memory/types.ts

@@ -32,7 +32,6 @@ const STRATEGY_DESCRIPTIONS: Record<MemoryStrategyType, string> = {
  SEMANTIC: 'Vector-based semantic search over memories',
  SUMMARIZATION: 'Compress and summarize conversation context',
  USER_PREFERENCE: 'Track and recall user preferences',
- CUSTOM: 'Custom memory strategy implementation',
 };
 
 export const MEMORY_STRATEGY_OPTIONS = MemoryStrategyTypeSchema.options.map(type => ({

src/schema/llm-compacted/agentcore.ts

@@ -27,7 +27,7 @@ type PythonRuntime = 'PYTHON_3_10' | 'PYTHON_3_11' | 'PYTHON_3_12' | 'PYTHON_3_1
 type NodeRuntime = 'NODE_18' | 'NODE_20' | 'NODE_22';
 type RuntimeVersion = PythonRuntime | NodeRuntime;
 type NetworkMode = 'PUBLIC' | 'PRIVATE';
-type MemoryStrategyType = 'SEMANTIC' | 'SUMMARIZATION' | 'USER_PREFERENCE' | 'CUSTOM';
+type MemoryStrategyType = 'SEMANTIC' | 'SUMMARIZATION' | 'USER_PREFERENCE';
 
 // ─────────────────────────────────────────────────────────────────────────────
 // AGENT

src/schema/schemas/primitives/__tests__/memory.test.ts

@@ -0,0 +1,89 @@
+import { DEFAULT_STRATEGY_NAMESPACES, MemoryStrategySchema, MemoryStrategyTypeSchema } from '../memory';
+import { describe, expect, it } from 'vitest';
+
+describe('MemoryStrategyTypeSchema', () => {
+ describe('valid strategy types', () => {
+ it('accepts SEMANTIC', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('SEMANTIC').success).toBe(true);
+ });
+
+ it('accepts SUMMARIZATION', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('SUMMARIZATION').success).toBe(true);
+ });
+
+ it('accepts USER_PREFERENCE', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('USER_PREFERENCE').success).toBe(true);
+ });
+ });
+
+ describe('invalid strategy types', () => {
+ // Issue #235: CUSTOM strategy has been removed
+ it('rejects CUSTOM strategy', () => {
+ const result = MemoryStrategyTypeSchema.safeParse('CUSTOM');
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects arbitrary invalid strategies', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('INVALID').success).toBe(false);
+ expect(MemoryStrategyTypeSchema.safeParse('').success).toBe(false);
+ expect(MemoryStrategyTypeSchema.safeParse('semantic').success).toBe(false); // lowercase
+ });
+ });
+
+ describe('schema options', () => {
+ it('only contains three valid strategies', () => {
+ expect(MemoryStrategyTypeSchema.options).toEqual(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE']);
+ expect(MemoryStrategyTypeSchema.options).not.toContain('CUSTOM');
+ });
+ });
+});
+
+describe('MemoryStrategySchema', () => {
+ it('validates strategy with required type field', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'SEMANTIC' });
+ expect(result.success).toBe(true);
+ });
+
+ it('validates strategy with optional fields', () => {
+ const result = MemoryStrategySchema.safeParse({
+ type: 'SEMANTIC',
+ name: 'myStrategy',
+ description: 'A description',
+ namespaces: ['/users/{actorId}/facts'],
+ });
+ expect(result.success).toBe(true);
+ });
+
+ it('rejects strategy with CUSTOM type', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'CUSTOM' });
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects strategy with invalid type', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'INVALID' });
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects strategy without type', () => {
+ const result = MemoryStrategySchema.safeParse({ name: 'myStrategy' });
+ expect(result.success).toBe(false);
+ });
+});
+
+describe('DEFAULT_STRATEGY_NAMESPACES', () => {
+ it('has default namespaces for SEMANTIC', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.SEMANTIC).toEqual(['/users/{actorId}/facts']);
+ });
+
+ it('has default namespaces for USER_PREFERENCE', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.USER_PREFERENCE).toEqual(['/users/{actorId}/preferences']);
+ });
+
+ it('has default namespaces for SUMMARIZATION', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.SUMMARIZATION).toEqual(['/summaries/{actorId}/{sessionId}']);
+ });
+
+ it('does not have default namespaces for CUSTOM (removed)', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES).not.toHaveProperty('CUSTOM');
+ });
+});

src/schema/schemas/primitives/memory.ts

@@ -10,16 +10,14 @@ import { z } from 'zod';
  * - SEMANTIC → SemanticMemoryStrategy
  * - SUMMARIZATION → SummaryMemoryStrategy (note: CloudFormation uses "Summary")
  * - USER_PREFERENCE → UserPreferenceMemoryStrategy
- * - CUSTOM → CustomMemoryStrategy
  * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-bedrockagentcore-memory-memorystrategy.html
  */
-export const MemoryStrategyTypeSchema = z.enum(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE', 'CUSTOM']);
+export const MemoryStrategyTypeSchema = z.enum(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE']);
 export type MemoryStrategyType = z.infer<typeof MemoryStrategyTypeSchema>;
 
 /**
  * Default namespaces for each memory strategy type.
  * These match the patterns generated in CLI session.py templates.
- * CUSTOM strategy intentionally has no default namespace.
  */
 export const DEFAULT_STRATEGY_NAMESPACES: Partial<Record<MemoryStrategyType, string[]>> = {
  SEMANTIC: ['/users/{actorId}/facts'],

src/assets/__tests__/__snapshots__/assets.snapshot.test.ts.snap

@@ -2829,7 +2829,7 @@ file maps to a JSON config file and includes validation constraints as comments.
 - **BuildType**: \`'CodeZip'\` | \`'Container'\`
 - **NetworkMode**: \`'PUBLIC'\` | \`'PRIVATE'\`
 - **RuntimeVersion**: \`'PYTHON_3_12'\` | \`'PYTHON_3_13'\` | \`'NODE_18'\` | \`'NODE_20'\` | \`'NODE_22'\`
-- **MemoryStrategyType**: \`'SEMANTIC'\` | \`'SUMMARIZATION'\` | \`'USER_PREFERENCE'\` | \`'CUSTOM'\`
+- **MemoryStrategyType**: \`'SEMANTIC'\` | \`'SUMMARIZATION'\` | \`'USER_PREFERENCE'\`
 
 ### Supported Frameworks (for template agents)
 

src/assets/agents/AGENTS.md

@@ -63,7 +63,7 @@ file maps to a JSON config file and includes validation constraints as comments.
 - **BuildType**: `'CodeZip'` | `'Container'`
 - **NetworkMode**: `'PUBLIC'` | `'PRIVATE'`
 - **RuntimeVersion**: `'PYTHON_3_12'` | `'PYTHON_3_13'` | `'NODE_18'` | `'NODE_20'` | `'NODE_22'`
-- **MemoryStrategyType**: `'SEMANTIC'` | `'SUMMARIZATION'` | `'USER_PREFERENCE'` | `'CUSTOM'`
+- **MemoryStrategyType**: `'SEMANTIC'` | `'SUMMARIZATION'` | `'USER_PREFERENCE'`
 
 ### Supported Frameworks (for template agents)
 

src/cli/commands/add/__tests__/add-memory.test.ts

@@ -50,6 +50,18 @@ describe('add memory command', () => {
  expect(json.success).toBe(false);
  expect(json.error.includes('INVALID'), `Error: ${json.error}`).toBeTruthy();
  });
+
+ // Issue #235: CUSTOM strategy has been removed
+ it('rejects CUSTOM strategy', async () => {
+ const result = await runCLI(
+ ['add', 'memory', '--name', 'testCustom', '--strategies', 'CUSTOM', '--json'],
+ projectDir
+ );
+ expect(result.exitCode).toBe(1);
+ const json = JSON.parse(result.stdout);
+ expect(json.success).toBe(false);
+ expect(json.error.includes('CUSTOM'), `Error: ${json.error}`).toBeTruthy();
+ });
  });
 
  describe('memory creation', () => {

src/cli/commands/add/__tests__/validate.test.ts

@@ -313,9 +313,51 @@ describe('validate', () => {
  expect(validateAddMemoryOptions(validMemoryOptions)).toEqual({ valid: true });
  // Test all valid strategies
  expect(
- validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION,USER_PREFERENCE,CUSTOM' })
+ validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION,USER_PREFERENCE' })
  ).toEqual({ valid: true });
  });
+
+ // AC23: CUSTOM strategy is not supported (Issue #235)
+ it('rejects CUSTOM strategy', () => {
+ const result = validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'CUSTOM' });
+ expect(result.valid).toBe(false);
+ expect(result.error).toContain('Invalid strategy: CUSTOM');
+ });
+
+ it('rejects CUSTOM even when mixed with valid strategies', () => {
+ const result = validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,CUSTOM' });
+ expect(result.valid).toBe(false);
+ expect(result.error).toContain('Invalid strategy: CUSTOM');
+ });
+
+ // AC24: Each individual valid strategy should pass
+ it('accepts each valid strategy individually', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC' })).toEqual({ valid: true });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SUMMARIZATION' })).toEqual({ valid: true });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ });
+
+ // AC25: Valid strategy combinations should pass
+ it('accepts valid strategy combinations', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION' })).toEqual({
+ valid: true,
+ });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SUMMARIZATION,USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ });
+
+ // AC26: Strategies with whitespace should be handled
+ it('handles strategies with whitespace', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: ' SEMANTIC , SUMMARIZATION ' })).toEqual({
+ valid: true,
+ });
+ });
  });
 
  describe('validateAddIdentityOptions', () => {

src/cli/commands/add/command.tsx

@@ -316,7 +316,7 @@ export function registerAdd(program: Command) {
  .option('--name <name>', 'Memory name [non-interactive]')
  .option(
  '--strategies <types>',
- 'Comma-separated strategies: SEMANTIC, SUMMARIZATION, USER_PREFERENCE, CUSTOM [non-interactive]'
+ 'Comma-separated strategies: SEMANTIC, SUMMARIZATION, USER_PREFERENCE [non-interactive]'
  )
  .option('--expiry <days>', 'Event expiry duration in days (default: 30) [non-interactive]', parseInt)
  .option('--json', 'Output as JSON [non-interactive]')

src/cli/commands/add/validate.ts

@@ -22,7 +22,7 @@ export interface ValidationResult {
 // Constants
 const MEMORY_OPTIONS = ['none', 'shortTerm', 'longAndShortTerm'] as const;
 const OIDC_WELL_KNOWN_SUFFIX = '/.well-known/openid-configuration';
-const VALID_STRATEGIES = ['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE', 'CUSTOM'];
+const VALID_STRATEGIES = ['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE'];
 
 // Agent validation
 export function validateAddAgentOptions(options: AddAgentOptions): ValidationResult {

src/cli/tui/screens/memory/types.ts

@@ -32,7 +32,6 @@ const STRATEGY_DESCRIPTIONS: Record<MemoryStrategyType, string> = {
  SEMANTIC: 'Vector-based semantic search over memories',
  SUMMARIZATION: 'Compress and summarize conversation context',
  USER_PREFERENCE: 'Track and recall user preferences',
- CUSTOM: 'Custom memory strategy implementation',
 };
 
 export const MEMORY_STRATEGY_OPTIONS = MemoryStrategyTypeSchema.options.map(type => ({

src/schema/llm-compacted/agentcore.ts

@@ -27,7 +27,7 @@ type PythonRuntime = 'PYTHON_3_10' | 'PYTHON_3_11' | 'PYTHON_3_12' | 'PYTHON_3_1
 type NodeRuntime = 'NODE_18' | 'NODE_20' | 'NODE_22';
 type RuntimeVersion = PythonRuntime | NodeRuntime;
 type NetworkMode = 'PUBLIC' | 'PRIVATE';
-type MemoryStrategyType = 'SEMANTIC' | 'SUMMARIZATION' | 'USER_PREFERENCE' | 'CUSTOM';
+type MemoryStrategyType = 'SEMANTIC' | 'SUMMARIZATION' | 'USER_PREFERENCE';
 
 // ─────────────────────────────────────────────────────────────────────────────
 // AGENT

src/schema/schemas/primitives/__tests__/memory.test.ts

@@ -0,0 +1,89 @@
+import { DEFAULT_STRATEGY_NAMESPACES, MemoryStrategySchema, MemoryStrategyTypeSchema } from '../memory';
+import { describe, expect, it } from 'vitest';
+
+describe('MemoryStrategyTypeSchema', () => {
+ describe('valid strategy types', () => {
+ it('accepts SEMANTIC', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('SEMANTIC').success).toBe(true);
+ });
+
+ it('accepts SUMMARIZATION', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('SUMMARIZATION').success).toBe(true);
+ });
+
+ it('accepts USER_PREFERENCE', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('USER_PREFERENCE').success).toBe(true);
+ });
+ });
+
+ describe('invalid strategy types', () => {
+ // Issue #235: CUSTOM strategy has been removed
+ it('rejects CUSTOM strategy', () => {
+ const result = MemoryStrategyTypeSchema.safeParse('CUSTOM');
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects arbitrary invalid strategies', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('INVALID').success).toBe(false);
+ expect(MemoryStrategyTypeSchema.safeParse('').success).toBe(false);
+ expect(MemoryStrategyTypeSchema.safeParse('semantic').success).toBe(false); // lowercase
+ });
+ });
+
+ describe('schema options', () => {
+ it('only contains three valid strategies', () => {
+ expect(MemoryStrategyTypeSchema.options).toEqual(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE']);
+ expect(MemoryStrategyTypeSchema.options).not.toContain('CUSTOM');
+ });
+ });
+});
+
+describe('MemoryStrategySchema', () => {
+ it('validates strategy with required type field', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'SEMANTIC' });
+ expect(result.success).toBe(true);
+ });
+
+ it('validates strategy with optional fields', () => {
+ const result = MemoryStrategySchema.safeParse({
+ type: 'SEMANTIC',
+ name: 'myStrategy',
+ description: 'A description',
+ namespaces: ['/users/{actorId}/facts'],
+ });
+ expect(result.success).toBe(true);
+ });
+
+ it('rejects strategy with CUSTOM type', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'CUSTOM' });
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects strategy with invalid type', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'INVALID' });
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects strategy without type', () => {
+ const result = MemoryStrategySchema.safeParse({ name: 'myStrategy' });
+ expect(result.success).toBe(false);
+ });
+});
+
+describe('DEFAULT_STRATEGY_NAMESPACES', () => {
+ it('has default namespaces for SEMANTIC', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.SEMANTIC).toEqual(['/users/{actorId}/facts']);
+ });
+
+ it('has default namespaces for USER_PREFERENCE', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.USER_PREFERENCE).toEqual(['/users/{actorId}/preferences']);
+ });
+
+ it('has default namespaces for SUMMARIZATION', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.SUMMARIZATION).toEqual(['/summaries/{actorId}/{sessionId}']);
+ });
+
+ it('does not have default namespaces for CUSTOM (removed)', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES).not.toHaveProperty('CUSTOM');
+ });
+});

src/schema/schemas/primitives/memory.ts

@@ -10,16 +10,14 @@ import { z } from 'zod';
  * - SEMANTIC → SemanticMemoryStrategy
  * - SUMMARIZATION → SummaryMemoryStrategy (note: CloudFormation uses "Summary")
  * - USER_PREFERENCE → UserPreferenceMemoryStrategy
- * - CUSTOM → CustomMemoryStrategy
  * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-bedrockagentcore-memory-memorystrategy.html
  */
-export const MemoryStrategyTypeSchema = z.enum(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE', 'CUSTOM']);
+export const MemoryStrategyTypeSchema = z.enum(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE']);
 export type MemoryStrategyType = z.infer<typeof MemoryStrategyTypeSchema>;
 
 /**
  * Default namespaces for each memory strategy type.
  * These match the patterns generated in CLI session.py templates.
- * CUSTOM strategy intentionally has no default namespace.
  */
 export const DEFAULT_STRATEGY_NAMESPACES: Partial<Record<MemoryStrategyType, string[]>> = {
  SEMANTIC: ['/users/{actorId}/facts'],

src/assets/__tests__/__snapshots__/assets.snapshot.test.ts.snap

@@ -2829,7 +2829,7 @@ file maps to a JSON config file and includes validation constraints as comments.
 - **BuildType**: \`'CodeZip'\` | \`'Container'\`
 - **NetworkMode**: \`'PUBLIC'\` | \`'PRIVATE'\`
 - **RuntimeVersion**: \`'PYTHON_3_12'\` | \`'PYTHON_3_13'\` | \`'NODE_18'\` | \`'NODE_20'\` | \`'NODE_22'\`
-- **MemoryStrategyType**: \`'SEMANTIC'\` | \`'SUMMARIZATION'\` | \`'USER_PREFERENCE'\` | \`'CUSTOM'\`
+- **MemoryStrategyType**: \`'SEMANTIC'\` | \`'SUMMARIZATION'\` | \`'USER_PREFERENCE'\`
 
 ### Supported Frameworks (for template agents)
 

src/assets/agents/AGENTS.md

@@ -63,7 +63,7 @@ file maps to a JSON config file and includes validation constraints as comments.
 - **BuildType**: `'CodeZip'` | `'Container'`
 - **NetworkMode**: `'PUBLIC'` | `'PRIVATE'`
 - **RuntimeVersion**: `'PYTHON_3_12'` | `'PYTHON_3_13'` | `'NODE_18'` | `'NODE_20'` | `'NODE_22'`
-- **MemoryStrategyType**: `'SEMANTIC'` | `'SUMMARIZATION'` | `'USER_PREFERENCE'` | `'CUSTOM'`
+- **MemoryStrategyType**: `'SEMANTIC'` | `'SUMMARIZATION'` | `'USER_PREFERENCE'`
 
 ### Supported Frameworks (for template agents)
 

src/cli/commands/add/__tests__/add-memory.test.ts

@@ -50,6 +50,18 @@ describe('add memory command', () => {
  expect(json.success).toBe(false);
  expect(json.error.includes('INVALID'), `Error: ${json.error}`).toBeTruthy();
  });
+
+ // Issue #235: CUSTOM strategy has been removed
+ it('rejects CUSTOM strategy', async () => {
+ const result = await runCLI(
+ ['add', 'memory', '--name', 'testCustom', '--strategies', 'CUSTOM', '--json'],
+ projectDir
+ );
+ expect(result.exitCode).toBe(1);
+ const json = JSON.parse(result.stdout);
+ expect(json.success).toBe(false);
+ expect(json.error.includes('CUSTOM'), `Error: ${json.error}`).toBeTruthy();
+ });
  });
 
  describe('memory creation', () => {

src/cli/commands/add/__tests__/validate.test.ts

@@ -313,9 +313,51 @@ describe('validate', () => {
  expect(validateAddMemoryOptions(validMemoryOptions)).toEqual({ valid: true });
  // Test all valid strategies
  expect(
- validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION,USER_PREFERENCE,CUSTOM' })
+ validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION,USER_PREFERENCE' })
  ).toEqual({ valid: true });
  });
+
+ // AC23: CUSTOM strategy is not supported (Issue #235)
+ it('rejects CUSTOM strategy', () => {
+ const result = validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'CUSTOM' });
+ expect(result.valid).toBe(false);
+ expect(result.error).toContain('Invalid strategy: CUSTOM');
+ });
+
+ it('rejects CUSTOM even when mixed with valid strategies', () => {
+ const result = validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,CUSTOM' });
+ expect(result.valid).toBe(false);
+ expect(result.error).toContain('Invalid strategy: CUSTOM');
+ });
+
+ // AC24: Each individual valid strategy should pass
+ it('accepts each valid strategy individually', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC' })).toEqual({ valid: true });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SUMMARIZATION' })).toEqual({ valid: true });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ });
+
+ // AC25: Valid strategy combinations should pass
+ it('accepts valid strategy combinations', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,SUMMARIZATION' })).toEqual({
+ valid: true,
+ });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SEMANTIC,USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: 'SUMMARIZATION,USER_PREFERENCE' })).toEqual({
+ valid: true,
+ });
+ });
+
+ // AC26: Strategies with whitespace should be handled
+ it('handles strategies with whitespace', () => {
+ expect(validateAddMemoryOptions({ ...validMemoryOptions, strategies: ' SEMANTIC , SUMMARIZATION ' })).toEqual({
+ valid: true,
+ });
+ });
  });
 
  describe('validateAddIdentityOptions', () => {

src/cli/commands/add/command.tsx

@@ -316,7 +316,7 @@ export function registerAdd(program: Command) {
  .option('--name <name>', 'Memory name [non-interactive]')
  .option(
  '--strategies <types>',
- 'Comma-separated strategies: SEMANTIC, SUMMARIZATION, USER_PREFERENCE, CUSTOM [non-interactive]'
+ 'Comma-separated strategies: SEMANTIC, SUMMARIZATION, USER_PREFERENCE [non-interactive]'
  )
  .option('--expiry <days>', 'Event expiry duration in days (default: 30) [non-interactive]', parseInt)
  .option('--json', 'Output as JSON [non-interactive]')

src/cli/commands/add/validate.ts

@@ -22,7 +22,7 @@ export interface ValidationResult {
 // Constants
 const MEMORY_OPTIONS = ['none', 'shortTerm', 'longAndShortTerm'] as const;
 const OIDC_WELL_KNOWN_SUFFIX = '/.well-known/openid-configuration';
-const VALID_STRATEGIES = ['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE', 'CUSTOM'];
+const VALID_STRATEGIES = ['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE'];
 
 // Agent validation
 export function validateAddAgentOptions(options: AddAgentOptions): ValidationResult {

src/cli/tui/screens/memory/types.ts

@@ -32,7 +32,6 @@ const STRATEGY_DESCRIPTIONS: Record<MemoryStrategyType, string> = {
  SEMANTIC: 'Vector-based semantic search over memories',
  SUMMARIZATION: 'Compress and summarize conversation context',
  USER_PREFERENCE: 'Track and recall user preferences',
- CUSTOM: 'Custom memory strategy implementation',
 };
 
 export const MEMORY_STRATEGY_OPTIONS = MemoryStrategyTypeSchema.options.map(type => ({

src/schema/llm-compacted/agentcore.ts

@@ -27,7 +27,7 @@ type PythonRuntime = 'PYTHON_3_10' | 'PYTHON_3_11' | 'PYTHON_3_12' | 'PYTHON_3_1
 type NodeRuntime = 'NODE_18' | 'NODE_20' | 'NODE_22';
 type RuntimeVersion = PythonRuntime | NodeRuntime;
 type NetworkMode = 'PUBLIC' | 'PRIVATE';
-type MemoryStrategyType = 'SEMANTIC' | 'SUMMARIZATION' | 'USER_PREFERENCE' | 'CUSTOM';
+type MemoryStrategyType = 'SEMANTIC' | 'SUMMARIZATION' | 'USER_PREFERENCE';
 
 // ─────────────────────────────────────────────────────────────────────────────
 // AGENT

src/schema/schemas/primitives/__tests__/memory.test.ts

@@ -0,0 +1,89 @@
+import { DEFAULT_STRATEGY_NAMESPACES, MemoryStrategySchema, MemoryStrategyTypeSchema } from '../memory';
+import { describe, expect, it } from 'vitest';
+
+describe('MemoryStrategyTypeSchema', () => {
+ describe('valid strategy types', () => {
+ it('accepts SEMANTIC', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('SEMANTIC').success).toBe(true);
+ });
+
+ it('accepts SUMMARIZATION', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('SUMMARIZATION').success).toBe(true);
+ });
+
+ it('accepts USER_PREFERENCE', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('USER_PREFERENCE').success).toBe(true);
+ });
+ });
+
+ describe('invalid strategy types', () => {
+ // Issue #235: CUSTOM strategy has been removed
+ it('rejects CUSTOM strategy', () => {
+ const result = MemoryStrategyTypeSchema.safeParse('CUSTOM');
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects arbitrary invalid strategies', () => {
+ expect(MemoryStrategyTypeSchema.safeParse('INVALID').success).toBe(false);
+ expect(MemoryStrategyTypeSchema.safeParse('').success).toBe(false);
+ expect(MemoryStrategyTypeSchema.safeParse('semantic').success).toBe(false); // lowercase
+ });
+ });
+
+ describe('schema options', () => {
+ it('only contains three valid strategies', () => {
+ expect(MemoryStrategyTypeSchema.options).toEqual(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE']);
+ expect(MemoryStrategyTypeSchema.options).not.toContain('CUSTOM');
+ });
+ });
+});
+
+describe('MemoryStrategySchema', () => {
+ it('validates strategy with required type field', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'SEMANTIC' });
+ expect(result.success).toBe(true);
+ });
+
+ it('validates strategy with optional fields', () => {
+ const result = MemoryStrategySchema.safeParse({
+ type: 'SEMANTIC',
+ name: 'myStrategy',
+ description: 'A description',
+ namespaces: ['/users/{actorId}/facts'],
+ });
+ expect(result.success).toBe(true);
+ });
+
+ it('rejects strategy with CUSTOM type', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'CUSTOM' });
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects strategy with invalid type', () => {
+ const result = MemoryStrategySchema.safeParse({ type: 'INVALID' });
+ expect(result.success).toBe(false);
+ });
+
+ it('rejects strategy without type', () => {
+ const result = MemoryStrategySchema.safeParse({ name: 'myStrategy' });
+ expect(result.success).toBe(false);
+ });
+});
+
+describe('DEFAULT_STRATEGY_NAMESPACES', () => {
+ it('has default namespaces for SEMANTIC', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.SEMANTIC).toEqual(['/users/{actorId}/facts']);
+ });
+
+ it('has default namespaces for USER_PREFERENCE', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.USER_PREFERENCE).toEqual(['/users/{actorId}/preferences']);
+ });
+
+ it('has default namespaces for SUMMARIZATION', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES.SUMMARIZATION).toEqual(['/summaries/{actorId}/{sessionId}']);
+ });
+
+ it('does not have default namespaces for CUSTOM (removed)', () => {
+ expect(DEFAULT_STRATEGY_NAMESPACES).not.toHaveProperty('CUSTOM');
+ });
+});

src/schema/schemas/primitives/memory.ts

@@ -10,16 +10,14 @@ import { z } from 'zod';
  * - SEMANTIC → SemanticMemoryStrategy
  * - SUMMARIZATION → SummaryMemoryStrategy (note: CloudFormation uses "Summary")
  * - USER_PREFERENCE → UserPreferenceMemoryStrategy
- * - CUSTOM → CustomMemoryStrategy
  * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-bedrockagentcore-memory-memorystrategy.html
  */
-export const MemoryStrategyTypeSchema = z.enum(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE', 'CUSTOM']);
+export const MemoryStrategyTypeSchema = z.enum(['SEMANTIC', 'SUMMARIZATION', 'USER_PREFERENCE']);
 export type MemoryStrategyType = z.infer<typeof MemoryStrategyTypeSchema>;
 
 /**
  * Default namespaces for each memory strategy type.
  * These match the patterns generated in CLI session.py templates.
- * CUSTOM strategy intentionally has no default namespace.
  */
 export const DEFAULT_STRATEGY_NAMESPACES: Partial<Record<MemoryStrategyType, string[]>> = {
  SEMANTIC: ['/users/{actorId}/facts'],