crewly 1.0.0

package/dist/backend/backend/src/controllers/memory/memory.controller.d.ts

@@ -0,0 +1,183 @@
+/**
+ * Memory REST Controller
+ *
+ * Exposes agent memory operations via REST API for orchestrator bash skills.
+ * Wraps the unified MemoryService to provide HTTP endpoints for storing,
+ * retrieving, and recording learnings in agent and project memory.
+ *
+ * @module controllers/memory/memory.controller
+ */
+import type { Request, Response, NextFunction } from 'express';
+/**
+ * POST /api/memory/remember
+ *
+ * Store knowledge in agent or project memory. The content is categorized
+ * and routed to the appropriate memory store based on the scope parameter.
+ *
+ * @param req - Express request with body: { agentId, content, category, scope, projectPath?, metadata? }
+ * @param res - Express response returning { success, entryId }
+ * @param next - Express next function for error propagation
+ *
+ * @example
+ * ```
+ * POST /api/memory/remember
+ * {
+ *   "agentId": "dev-001",
+ *   "content": "Always validate user input before processing",
+ *   "category": "pattern",
+ *   "scope": "agent"
+ * }
+ * ```
+ */
+export declare function remember(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * POST /api/memory/recall
+ *
+ * Retrieve relevant knowledge from agent and/or project memory.
+ * Performs relevance-based search across the specified scope(s).
+ *
+ * @param req - Express request with body: { agentId, context, scope?, limit?, projectPath? }
+ * @param res - Express response returning { success, data: RecallResult }
+ * @param next - Express next function for error propagation
+ *
+ * @example
+ * ```
+ * POST /api/memory/recall
+ * {
+ *   "agentId": "dev-001",
+ *   "context": "error handling in API endpoints",
+ *   "scope": "both",
+ *   "projectPath": "/path/to/project",
+ *   "limit": 10
+ * }
+ * ```
+ */
+export declare function recall(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * POST /api/memory/record-learning
+ *
+ * Quickly record a learning or discovery. The learning is stored in
+ * project memory and optionally promoted to agent memory if it contains
+ * role-relevant patterns.
+ *
+ * @param req - Express request with body: { agentId, agentRole, projectPath, learning, relatedTask?, relatedFiles? }
+ * @param res - Express response returning { success }
+ * @param next - Express next function for error propagation
+ *
+ * @example
+ * ```
+ * POST /api/memory/record-learning
+ * {
+ *   "agentId": "dev-001",
+ *   "agentRole": "developer",
+ *   "projectPath": "/path/to/project",
+ *   "learning": "Always use async/await for database operations",
+ *   "relatedTask": "TICKET-456",
+ *   "relatedFiles": ["src/db/queries.ts"]
+ * }
+ * ```
+ */
+export declare function recordLearning(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * POST /api/memory/goals
+ *
+ * Set or append a project goal.
+ *
+ * @param req - Express request with body: { goal, projectPath, setBy? }
+ * @param res - Express response returning { success }
+ * @param next - Express next function for error propagation
+ */
+export declare function setGoal(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * GET /api/memory/goals
+ *
+ * Get active project goals.
+ *
+ * @param req - Express request with query: { projectPath }
+ * @param res - Express response returning { success, data }
+ * @param next - Express next function for error propagation
+ */
+export declare function getGoals(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * POST /api/memory/focus
+ *
+ * Update the team's current focus.
+ *
+ * @param req - Express request with body: { focus, projectPath, updatedBy? }
+ * @param res - Express response returning { success }
+ * @param next - Express next function for error propagation
+ */
+export declare function updateFocus(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * GET /api/memory/focus
+ *
+ * Get the team's current focus.
+ *
+ * @param req - Express request with query: { projectPath }
+ * @param res - Express response returning { success, data }
+ * @param next - Express next function for error propagation
+ */
+export declare function getFocus(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * POST /api/memory/daily-log
+ *
+ * Append an entry to today's daily log.
+ *
+ * @param req - Express request with body: { projectPath, agentId, role, entry }
+ * @param res - Express response returning { success }
+ * @param next - Express next function for error propagation
+ */
+export declare function appendDailyLog(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * GET /api/memory/daily-log
+ *
+ * Get today's daily log.
+ *
+ * @param req - Express request with query: { projectPath }
+ * @param res - Express response returning { success, data }
+ * @param next - Express next function for error propagation
+ */
+export declare function getDailyLog(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * POST /api/memory/record-success
+ *
+ * Record a successful pattern or approach.
+ *
+ * @param req - Express request with body: { projectPath, teamMemberId, description, context? }
+ * @param res - Express response returning { success }
+ * @param next - Express next function for error propagation
+ */
+export declare function recordSuccess(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * POST /api/memory/record-failure
+ *
+ * Record a failed approach or pitfall to avoid.
+ *
+ * @param req - Express request with body: { projectPath, teamMemberId, description, context? }
+ * @param res - Express response returning { success }
+ * @param next - Express next function for error propagation
+ */
+export declare function recordFailure(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * POST /api/memory/my-context
+ *
+ * Retrieve combined context for an agent, including relevant memories,
+ * project goals, current focus, today's daily log, and recent learnings.
+ * This provides a single-call context briefing for agent startup or task transitions.
+ *
+ * @param req - Express request with body: { agentId, agentRole, projectPath }
+ * @param res - Express response returning { success, data: { memories, goals, focus, dailyLog, learnings } }
+ * @param next - Express next function for error propagation
+ *
+ * @example
+ * ```
+ * POST /api/memory/my-context
+ * {
+ *   "agentId": "dev-001",
+ *   "agentRole": "developer",
+ *   "projectPath": "/path/to/project"
+ * }
+ * ```
+ */
+export declare function getMyContext(req: Request, res: Response, next: NextFunction): Promise<void>;
+//# sourceMappingURL=memory.controller.d.ts.map

package/dist/backend/backend/src/controllers/memory/memory.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.controller.d.ts","sourceRoot":"","sources":["../../../../../../backend/src/controllers/memory/memory.controller.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAyB/D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAwD7F;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,MAAM,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAoD3F;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA+BnG;AAED;;;;;;;;GAQG;AACH,wBAAsB,OAAO,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAkB5F;AAED;;;;;;;;GAQG;AACH,wBAAsB,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAiB7F;AAED;;;;;;;;GAQG;AACH,wBAAsB,WAAW,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBhG;AAED;;;;;;;;GAQG;AACH,wBAAsB,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAiB7F;AAED;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBnG;AAED;;;;;;;;GAQG;AACH,wBAAsB,WAAW,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAiBhG;AAED;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBlG;AAED;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBlG;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA4DjG"}

package/dist/backend/backend/src/controllers/memory/memory.controller.js

@@ -0,0 +1,505 @@
+/**
+ * Memory REST Controller
+ *
+ * Exposes agent memory operations via REST API for orchestrator bash skills.
+ * Wraps the unified MemoryService to provide HTTP endpoints for storing,
+ * retrieving, and recording learnings in agent and project memory.
+ *
+ * @module controllers/memory/memory.controller
+ */
+import { MemoryService } from '../../services/memory/memory.service.js';
+import { GoalTrackingService } from '../../services/memory/goal-tracking.service.js';
+import { DailyLogService } from '../../services/memory/daily-log.service.js';
+import { LearningAccumulationService } from '../../services/memory/learning-accumulation.service.js';
+import { KnowledgeService } from '../../services/knowledge/knowledge.service.js';
+import { LoggerService } from '../../services/core/logger.service.js';
+const logger = LoggerService.getInstance().createComponentLogger('MemoryController');
+/** Valid categories for the remember endpoint */
+const VALID_REMEMBER_CATEGORIES = new Set([
+    'fact', 'pattern', 'decision', 'gotcha', 'preference', 'relationship',
+]);
+/** Valid scopes for the remember endpoint */
+const VALID_REMEMBER_SCOPES = new Set(['agent', 'project']);
+/** Valid scopes for the recall endpoint */
+const VALID_RECALL_SCOPES = new Set(['agent', 'project', 'both']);
+/** Default character limit for learning accumulation tail reads */
+const LEARNING_TAIL_CHARS = 3000;
+/**
+ * POST /api/memory/remember
+ *
+ * Store knowledge in agent or project memory. The content is categorized
+ * and routed to the appropriate memory store based on the scope parameter.
+ *
+ * @param req - Express request with body: { agentId, content, category, scope, projectPath?, metadata? }
+ * @param res - Express response returning { success, entryId }
+ * @param next - Express next function for error propagation
+ *
+ * @example
+ * ```
+ * POST /api/memory/remember
+ * {
+ *   "agentId": "dev-001",
+ *   "content": "Always validate user input before processing",
+ *   "category": "pattern",
+ *   "scope": "agent"
+ * }
+ * ```
+ */
+export async function remember(req, res, next) {
+    try {
+        const { agentId, content, category, scope, projectPath, metadata } = req.body;
+        if (!agentId || !content || !category) {
+            res.status(400).json({
+                success: false,
+                error: 'Missing required parameters: agentId, content, category',
+            });
+            return;
+        }
+        if (!VALID_REMEMBER_CATEGORIES.has(category)) {
+            res.status(400).json({
+                success: false,
+                error: `Invalid category '${category}'. Must be one of: ${[...VALID_REMEMBER_CATEGORIES].join(', ')}`,
+            });
+            return;
+        }
+        const resolvedScope = scope || 'agent';
+        if (!VALID_REMEMBER_SCOPES.has(resolvedScope)) {
+            res.status(400).json({
+                success: false,
+                error: `Invalid scope '${resolvedScope}'. Must be one of: ${[...VALID_REMEMBER_SCOPES].join(', ')}`,
+            });
+            return;
+        }
+        if (resolvedScope === 'project' && !projectPath) {
+            res.status(400).json({
+                success: false,
+                error: 'projectPath is required when scope is "project"',
+            });
+            return;
+        }
+        const memoryService = MemoryService.getInstance();
+        const entryId = await memoryService.remember({
+            agentId,
+            content,
+            category: category,
+            scope: resolvedScope,
+            projectPath,
+            metadata,
+        });
+        logger.info('Memory stored via REST', { agentId, category, scope: resolvedScope });
+        res.json({ success: true, entryId });
+    }
+    catch (error) {
+        logger.error('Failed to store memory', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        next(error);
+    }
+}
+/**
+ * POST /api/memory/recall
+ *
+ * Retrieve relevant knowledge from agent and/or project memory.
+ * Performs relevance-based search across the specified scope(s).
+ *
+ * @param req - Express request with body: { agentId, context, scope?, limit?, projectPath? }
+ * @param res - Express response returning { success, data: RecallResult }
+ * @param next - Express next function for error propagation
+ *
+ * @example
+ * ```
+ * POST /api/memory/recall
+ * {
+ *   "agentId": "dev-001",
+ *   "context": "error handling in API endpoints",
+ *   "scope": "both",
+ *   "projectPath": "/path/to/project",
+ *   "limit": 10
+ * }
+ * ```
+ */
+export async function recall(req, res, next) {
+    try {
+        const { agentId, context, scope, limit, projectPath } = req.body;
+        if (!agentId || !context) {
+            res.status(400).json({
+                success: false,
+                error: 'Missing required parameters: agentId, context',
+            });
+            return;
+        }
+        const resolvedScope = scope || 'both';
+        if (!VALID_RECALL_SCOPES.has(resolvedScope)) {
+            res.status(400).json({
+                success: false,
+                error: `Invalid scope '${resolvedScope}'. Must be one of: ${[...VALID_RECALL_SCOPES].join(', ')}`,
+            });
+            return;
+        }
+        if ((resolvedScope === 'project' || resolvedScope === 'both') && !projectPath) {
+            res.status(400).json({
+                success: false,
+                error: 'projectPath is required when scope is "project" or "both"',
+            });
+            return;
+        }
+        const memoryService = MemoryService.getInstance();
+        const result = await memoryService.recall({
+            agentId,
+            context,
+            scope: resolvedScope,
+            limit: limit !== undefined ? Number(limit) : undefined,
+            projectPath,
+        });
+        logger.debug('Memory recalled via REST', {
+            agentId,
+            scope: resolvedScope,
+            agentCount: result.agentMemories.length,
+            projectCount: result.projectMemories.length,
+        });
+        res.json({ success: true, data: result });
+    }
+    catch (error) {
+        logger.error('Failed to recall memory', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        next(error);
+    }
+}
+/**
+ * POST /api/memory/record-learning
+ *
+ * Quickly record a learning or discovery. The learning is stored in
+ * project memory and optionally promoted to agent memory if it contains
+ * role-relevant patterns.
+ *
+ * @param req - Express request with body: { agentId, agentRole, projectPath, learning, relatedTask?, relatedFiles? }
+ * @param res - Express response returning { success }
+ * @param next - Express next function for error propagation
+ *
+ * @example
+ * ```
+ * POST /api/memory/record-learning
+ * {
+ *   "agentId": "dev-001",
+ *   "agentRole": "developer",
+ *   "projectPath": "/path/to/project",
+ *   "learning": "Always use async/await for database operations",
+ *   "relatedTask": "TICKET-456",
+ *   "relatedFiles": ["src/db/queries.ts"]
+ * }
+ * ```
+ */
+export async function recordLearning(req, res, next) {
+    try {
+        const { agentId, agentRole, projectPath, learning, relatedTask, relatedFiles } = req.body;
+        if (!agentId || !agentRole || !projectPath || !learning) {
+            res.status(400).json({
+                success: false,
+                error: 'Missing required parameters: agentId, agentRole, projectPath, learning',
+            });
+            return;
+        }
+        const memoryService = MemoryService.getInstance();
+        await memoryService.recordLearning({
+            agentId,
+            agentRole,
+            projectPath,
+            learning,
+            relatedTask,
+            relatedFiles,
+        });
+        logger.info('Learning recorded via REST', { agentId, agentRole, projectPath });
+        res.json({ success: true });
+    }
+    catch (error) {
+        logger.error('Failed to record learning', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        next(error);
+    }
+}
+/**
+ * POST /api/memory/goals
+ *
+ * Set or append a project goal.
+ *
+ * @param req - Express request with body: { goal, projectPath, setBy? }
+ * @param res - Express response returning { success }
+ * @param next - Express next function for error propagation
+ */
+export async function setGoal(req, res, next) {
+    try {
+        const { goal, projectPath, setBy } = req.body;
+        if (!goal || !projectPath) {
+            res.status(400).json({ success: false, error: 'Missing required parameters: goal, projectPath' });
+            return;
+        }
+        const service = GoalTrackingService.getInstance();
+        await service.setGoal(projectPath, goal, setBy);
+        logger.info('Goal set via REST', { projectPath, setBy });
+        res.json({ success: true });
+    }
+    catch (error) {
+        logger.error('Failed to set goal', { error: error instanceof Error ? error.message : String(error) });
+        next(error);
+    }
+}
+/**
+ * GET /api/memory/goals
+ *
+ * Get active project goals.
+ *
+ * @param req - Express request with query: { projectPath }
+ * @param res - Express response returning { success, data }
+ * @param next - Express next function for error propagation
+ */
+export async function getGoals(req, res, next) {
+    try {
+        const projectPath = req.query.projectPath;
+        if (!projectPath) {
+            res.status(400).json({ success: false, error: 'Missing required query parameter: projectPath' });
+            return;
+        }
+        const service = GoalTrackingService.getInstance();
+        const data = await service.getGoals(projectPath);
+        res.json({ success: true, data });
+    }
+    catch (error) {
+        logger.error('Failed to get goals', { error: error instanceof Error ? error.message : String(error) });
+        next(error);
+    }
+}
+/**
+ * POST /api/memory/focus
+ *
+ * Update the team's current focus.
+ *
+ * @param req - Express request with body: { focus, projectPath, updatedBy? }
+ * @param res - Express response returning { success }
+ * @param next - Express next function for error propagation
+ */
+export async function updateFocus(req, res, next) {
+    try {
+        const { focus, projectPath, updatedBy } = req.body;
+        if (!focus || !projectPath) {
+            res.status(400).json({ success: false, error: 'Missing required parameters: focus, projectPath' });
+            return;
+        }
+        const service = GoalTrackingService.getInstance();
+        await service.updateFocus(projectPath, focus, updatedBy);
+        logger.info('Focus updated via REST', { projectPath, updatedBy });
+        res.json({ success: true });
+    }
+    catch (error) {
+        logger.error('Failed to update focus', { error: error instanceof Error ? error.message : String(error) });
+        next(error);
+    }
+}
+/**
+ * GET /api/memory/focus
+ *
+ * Get the team's current focus.
+ *
+ * @param req - Express request with query: { projectPath }
+ * @param res - Express response returning { success, data }
+ * @param next - Express next function for error propagation
+ */
+export async function getFocus(req, res, next) {
+    try {
+        const projectPath = req.query.projectPath;
+        if (!projectPath) {
+            res.status(400).json({ success: false, error: 'Missing required query parameter: projectPath' });
+            return;
+        }
+        const service = GoalTrackingService.getInstance();
+        const data = await service.getCurrentFocus(projectPath);
+        res.json({ success: true, data });
+    }
+    catch (error) {
+        logger.error('Failed to get focus', { error: error instanceof Error ? error.message : String(error) });
+        next(error);
+    }
+}
+/**
+ * POST /api/memory/daily-log
+ *
+ * Append an entry to today's daily log.
+ *
+ * @param req - Express request with body: { projectPath, agentId, role, entry }
+ * @param res - Express response returning { success }
+ * @param next - Express next function for error propagation
+ */
+export async function appendDailyLog(req, res, next) {
+    try {
+        const { projectPath, agentId, role, entry } = req.body;
+        if (!projectPath || !agentId || !role || !entry) {
+            res.status(400).json({ success: false, error: 'Missing required parameters: projectPath, agentId, role, entry' });
+            return;
+        }
+        const service = DailyLogService.getInstance();
+        await service.appendEntry(projectPath, agentId, role, entry);
+        logger.debug('Daily log appended via REST', { projectPath, agentId, role });
+        res.json({ success: true });
+    }
+    catch (error) {
+        logger.error('Failed to append daily log', { error: error instanceof Error ? error.message : String(error) });
+        next(error);
+    }
+}
+/**
+ * GET /api/memory/daily-log
+ *
+ * Get today's daily log.
+ *
+ * @param req - Express request with query: { projectPath }
+ * @param res - Express response returning { success, data }
+ * @param next - Express next function for error propagation
+ */
+export async function getDailyLog(req, res, next) {
+    try {
+        const projectPath = req.query.projectPath;
+        if (!projectPath) {
+            res.status(400).json({ success: false, error: 'Missing required query parameter: projectPath' });
+            return;
+        }
+        const service = DailyLogService.getInstance();
+        const data = await service.getTodaysLog(projectPath);
+        res.json({ success: true, data });
+    }
+    catch (error) {
+        logger.error('Failed to get daily log', { error: error instanceof Error ? error.message : String(error) });
+        next(error);
+    }
+}
+/**
+ * POST /api/memory/record-success
+ *
+ * Record a successful pattern or approach.
+ *
+ * @param req - Express request with body: { projectPath, teamMemberId, description, context? }
+ * @param res - Express response returning { success }
+ * @param next - Express next function for error propagation
+ */
+export async function recordSuccess(req, res, next) {
+    try {
+        const { projectPath, teamMemberId, description, context, role } = req.body;
+        if (!projectPath || !description) {
+            res.status(400).json({ success: false, error: 'Missing required parameters: projectPath, description' });
+            return;
+        }
+        const service = LearningAccumulationService.getInstance();
+        await service.recordSuccess(projectPath, teamMemberId || 'unknown', role || 'unknown', description, context);
+        logger.info('Success recorded via REST', { projectPath, teamMemberId });
+        res.json({ success: true });
+    }
+    catch (error) {
+        logger.error('Failed to record success', { error: error instanceof Error ? error.message : String(error) });
+        next(error);
+    }
+}
+/**
+ * POST /api/memory/record-failure
+ *
+ * Record a failed approach or pitfall to avoid.
+ *
+ * @param req - Express request with body: { projectPath, teamMemberId, description, context? }
+ * @param res - Express response returning { success }
+ * @param next - Express next function for error propagation
+ */
+export async function recordFailure(req, res, next) {
+    try {
+        const { projectPath, teamMemberId, description, context, role } = req.body;
+        if (!projectPath || !description) {
+            res.status(400).json({ success: false, error: 'Missing required parameters: projectPath, description' });
+            return;
+        }
+        const service = LearningAccumulationService.getInstance();
+        await service.recordFailure(projectPath, teamMemberId || 'unknown', role || 'unknown', description, context);
+        logger.info('Failure recorded via REST', { projectPath, teamMemberId });
+        res.json({ success: true });
+    }
+    catch (error) {
+        logger.error('Failed to record failure', { error: error instanceof Error ? error.message : String(error) });
+        next(error);
+    }
+}
+/**
+ * POST /api/memory/my-context
+ *
+ * Retrieve combined context for an agent, including relevant memories,
+ * project goals, current focus, today's daily log, and recent learnings.
+ * This provides a single-call context briefing for agent startup or task transitions.
+ *
+ * @param req - Express request with body: { agentId, agentRole, projectPath }
+ * @param res - Express response returning { success, data: { memories, goals, focus, dailyLog, learnings } }
+ * @param next - Express next function for error propagation
+ *
+ * @example
+ * ```
+ * POST /api/memory/my-context
+ * {
+ *   "agentId": "dev-001",
+ *   "agentRole": "developer",
+ *   "projectPath": "/path/to/project"
+ * }
+ * ```
+ */
+export async function getMyContext(req, res, next) {
+    try {
+        const { agentId, agentRole, projectPath } = req.body;
+        if (!agentId || !agentRole || !projectPath) {
+            res.status(400).json({
+                success: false,
+                error: 'Missing required parameters: agentId, agentRole, projectPath',
+            });
+            return;
+        }
+        // Gather context from all memory subsystems in parallel
+        const memoryService = MemoryService.getInstance();
+        const goalService = GoalTrackingService.getInstance();
+        const dailyLogService = DailyLogService.getInstance();
+        const learningService = LearningAccumulationService.getInstance();
+        const knowledgeService = KnowledgeService.getInstance();
+        const [memories, goals, focus, dailyLog, successes, failures, globalKnowledgeDocs, projectKnowledgeDocs] = await Promise.all([
+            memoryService.recall({
+                agentId,
+                context: `${agentRole} agent context for current work`,
+                scope: 'both',
+                projectPath,
+            }),
+            goalService.getGoals(projectPath),
+            goalService.getCurrentFocus(projectPath),
+            dailyLogService.getTodaysLog(projectPath),
+            learningService.getSuccesses(projectPath, LEARNING_TAIL_CHARS),
+            learningService.getFailures(projectPath, LEARNING_TAIL_CHARS),
+            knowledgeService.listDocuments('global').catch(() => []),
+            knowledgeService.listDocuments('project', projectPath).catch(() => []),
+        ]);
+        logger.debug('Agent context retrieved via REST', { agentId, agentRole, projectPath });
+        res.json({
+            success: true,
+            data: {
+                memories,
+                goals,
+                focus,
+                dailyLog,
+                learnings: {
+                    successes,
+                    failures,
+                },
+                knowledgeDocs: {
+                    global: globalKnowledgeDocs,
+                    project: projectKnowledgeDocs,
+                },
+            },
+        });
+    }
+    catch (error) {
+        logger.error('Failed to get agent context', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        next(error);
+    }
+}
+//# sourceMappingURL=memory.controller.js.map