crewly 1.5.17 → 1.5.19

package/dist/backend/backend/src/types/intent-task.types.d.ts

@@ -0,0 +1,386 @@
+/**
+ * Intent Task Types — V2
+ *
+ * Defines the dual-layer Intent Task System with multi-intent decomposition:
+ * - Intent Layer: User messages decomposed into multiple intents, each classified by complexity (L0/L1/L2)
+ * - Execution Layer: Task -> Run -> Span model for tracking work
+ * - Association Layer: Schedule follow-up and project task linkage
+ *
+ * Key v2 change: One chat message can produce multiple intent tasks.
+ * Tasks are grouped by messageId and displayed as a todo list.
+ *
+ * Token usage binds to task_id + run_id via TokenUsageService integration.
+ *
+ * @module types/intent-task
+ */
+/**
+ * Intent complexity levels:
+ * - L0: Simple query — single agent, no tool calls (e.g., "what time is it?")
+ * - L1: Standard task — single agent, may use tools (e.g., "fix this bug")
+ * - L2: Complex task — multi-agent, multi-step orchestration (e.g., "build a feature")
+ */
+export type IntentLevel = 'L0' | 'L1' | 'L2';
+/**
+ * Intent classification labels for categorizing user requests
+ */
+export type IntentCategory = 'query' | 'code_change' | 'debugging' | 'deployment' | 'research' | 'review' | 'planning' | 'communication' | 'other';
+/**
+ * Lifecycle states for an intent task
+ */
+export type IntentTaskStatus = 'pending' | 'classified' | 'in_progress' | 'paused' | 'completed' | 'failed' | 'cancelled';
+/**
+ * Lifecycle states for a run within a task
+ */
+export type RunStatus = 'running' | 'completed' | 'failed' | 'cancelled';
+/**
+ * Span types for tracking granular execution steps
+ */
+export type SpanType = 'llm_call' | 'tool_call' | 'skill_call' | 'delegation' | 'waiting' | 'user_input';
+/**
+ * A span represents a single atomic operation within a run.
+ * Spans track LLM calls, tool executions, and delegations.
+ */
+export interface TaskSpan {
+    /** Unique span identifier */
+    id: string;
+    /** Parent run ID */
+    runId: string;
+    /** Type of operation */
+    type: SpanType;
+    /** Human-readable label (e.g., tool name, model name) */
+    label: string;
+    /** ISO timestamp when the span started */
+    startedAt: string;
+    /** ISO timestamp when the span ended (null if still running) */
+    endedAt: string | null;
+    /** Duration in milliseconds (computed on completion) */
+    durationMs: number | null;
+    /** Input tokens consumed (for llm_call spans) */
+    inputTokens: number;
+    /** Output tokens generated (for llm_call spans) */
+    outputTokens: number;
+    /** Direct cost override in USD (for skill_call spans with non-token costs) */
+    costOverride?: number;
+    /** Optional metadata (tool args preview, model name, etc.) */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * A run represents a single execution attempt of a task.
+ * A task may have multiple runs (retries, continuations).
+ */
+export interface TaskRun {
+    /** Unique run identifier */
+    id: string;
+    /** Parent task ID */
+    taskId: string;
+    /** Run sequence number (1-based) */
+    runNumber: number;
+    /** Agent session executing this run */
+    sessionName: string;
+    /** Current status */
+    status: RunStatus;
+    /** ISO timestamp when the run started */
+    startedAt: string;
+    /** ISO timestamp when the run ended */
+    endedAt: string | null;
+    /** Total input tokens across all spans */
+    totalInputTokens: number;
+    /** Total output tokens across all spans */
+    totalOutputTokens: number;
+    /** Computed LLM cost in USD */
+    cost: number;
+    /** Computed skill cost in USD (API calls, browser automation, etc.) */
+    skillCost: number;
+    /** Spans within this run */
+    spans: TaskSpan[];
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * An intent task represents a single decomposed intent from a user message,
+ * tracked through its lifecycle.
+ *
+ * V2: Multiple tasks can share the same messageId (from one chat message).
+ */
+export interface IntentTask {
+    /** Unique task identifier */
+    id: string;
+    /** ID of the originating chat message (groups tasks from the same message) */
+    messageId: string;
+    /** Original user input / intent description */
+    intent: string;
+    /** Classified complexity level */
+    level: IntentLevel;
+    /** Intent category */
+    category: IntentCategory;
+    /** Current lifecycle status */
+    status: IntentTaskStatus;
+    /** ISO timestamp when created */
+    createdAt: string;
+    /** ISO timestamp of last update */
+    updatedAt: string;
+    /** ISO timestamp when completed/failed */
+    completedAt: string | null;
+    /** Agent sessions involved */
+    assignedSessions: string[];
+    /** Execution runs */
+    runs: TaskRun[];
+    /** Aggregated input tokens across all runs */
+    totalInputTokens: number;
+    /** Aggregated output tokens across all runs */
+    totalOutputTokens: number;
+    /** Aggregated LLM cost in USD */
+    totalCost: number;
+    /** Aggregated skill cost in USD (API calls, browser automation, etc.) */
+    totalSkillCost: number;
+    /** Optional result summary */
+    result?: string;
+    /** Optional parent task ID for sub-task relationships */
+    parentTaskId?: string;
+    /** Optional tags for filtering */
+    tags?: string[];
+    /** Optional schedule ID for automatic follow-up checks */
+    scheduleId?: string;
+    /** Optional project task ID linking to .crewly/tasks/ project task */
+    projectTaskId?: string;
+    /** Order within the message (0-based, for display ordering) */
+    order: number;
+}
+/**
+ * A single decomposed intent extracted from a user message.
+ */
+export interface DecomposedIntent {
+    /** The extracted intent description */
+    intent: string;
+    /** Auto-classified complexity level */
+    level: IntentLevel;
+    /** Auto-classified category */
+    category: IntentCategory;
+}
+/**
+ * Result of decomposing a user message into multiple intents.
+ */
+export interface DecomposeResult {
+    /** The original user message */
+    originalMessage: string;
+    /** Generated message ID for grouping */
+    messageId: string;
+    /** Array of decomposed intents */
+    intents: DecomposedIntent[];
+}
+/**
+ * A message group containing all tasks from a single chat message.
+ * Used for the todo-list UI display.
+ */
+export interface MessageGroup {
+    /** Message ID shared by all tasks in this group */
+    messageId: string;
+    /** The original user message (reconstructed or stored) */
+    originalMessage: string;
+    /** ISO timestamp of the earliest task in this group */
+    createdAt: string;
+    /** Tasks belonging to this message, ordered by their order field */
+    tasks: IntentTaskSummary[];
+    /** Number of completed tasks in this group */
+    completedCount: number;
+    /** Total number of tasks in this group */
+    totalCount: number;
+}
+/**
+ * Request body for creating a new intent task
+ */
+export interface CreateIntentTaskInput {
+    /** User intent description */
+    intent: string;
+    /** Message ID to group tasks from the same chat message */
+    messageId?: string;
+    /** Optional pre-classified level (auto-classified if omitted) */
+    level?: IntentLevel;
+    /** Optional category (auto-classified if omitted) */
+    category?: IntentCategory;
+    /** Optional parent task ID */
+    parentTaskId?: string;
+    /** Optional tags */
+    tags?: string[];
+    /** Optional schedule ID for follow-up */
+    scheduleId?: string;
+    /** Optional project task ID */
+    projectTaskId?: string;
+    /** Optional order within message group */
+    order?: number;
+}
+/**
+ * Request body for decomposing a message into multiple intent tasks.
+ */
+export interface DecomposeMessageInput {
+    /** The full user message to decompose */
+    message: string;
+    /** Optional project task ID to associate all decomposed tasks with */
+    projectTaskId?: string;
+    /** Optional tags to apply to all decomposed tasks */
+    tags?: string[];
+    /** Whether to auto-create schedule follow-ups for each task */
+    autoSchedule?: boolean;
+}
+/**
+ * Request body for updating a task's status and metadata.
+ * Supports updating intent description, level, and category
+ * (useful when orchestrator LLM refines understanding).
+ */
+export interface UpdateIntentTaskInput {
+    /** New status */
+    status?: IntentTaskStatus;
+    /** Updated intent description (for LLM-driven refinement) */
+    intent?: string;
+    /** Updated complexity level */
+    level?: IntentLevel;
+    /** Updated category */
+    category?: IntentCategory;
+    /** Result summary (when completing) */
+    result?: string;
+    /** Additional sessions to assign */
+    assignedSessions?: string[];
+    /** Schedule ID to associate */
+    scheduleId?: string;
+}
+/**
+ * Request body for creating multiple intent tasks in a single batch.
+ * Used by the orchestrator to create all tasks from one chat message at once.
+ */
+export interface BatchCreateIntentTaskInput {
+    /** Array of tasks to create */
+    tasks: CreateIntentTaskInput[];
+    /** The original user message that produced these tasks */
+    originalMessage?: string;
+}
+/**
+ * Request body for starting a new run
+ */
+export interface StartRunInput {
+    /** Agent session executing the run */
+    sessionName: string;
+}
+/**
+ * Request body for recording a span
+ */
+export interface RecordSpanInput {
+    /** Span type */
+    type: SpanType;
+    /** Human-readable label */
+    label: string;
+    /** Input tokens (for llm_call) */
+    inputTokens?: number;
+    /** Output tokens (for llm_call) */
+    outputTokens?: number;
+    /** Duration in milliseconds */
+    durationMs?: number;
+    /** Direct cost override in USD (for skill_call spans with non-token costs) */
+    costOverride?: number;
+    /** Optional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Summary view of a task for list display
+ */
+export interface IntentTaskSummary {
+    /** Task ID */
+    id: string;
+    /** Message ID for grouping */
+    messageId: string;
+    /** Intent description (truncated) */
+    intent: string;
+    /** Complexity level */
+    level: IntentLevel;
+    /** Category */
+    category: IntentCategory;
+    /** Current status */
+    status: IntentTaskStatus;
+    /** When created */
+    createdAt: string;
+    /** When last updated */
+    updatedAt: string;
+    /** Number of runs */
+    runCount: number;
+    /** Total tokens (input + output) */
+    totalTokens: number;
+    /** Total LLM cost in USD */
+    totalCost: number;
+    /** Total skill cost in USD */
+    totalSkillCost: number;
+    /** Assigned sessions */
+    assignedSessions: string[];
+    /** Order within message group */
+    order: number;
+    /** Schedule ID if associated */
+    scheduleId?: string;
+    /** Project task ID if associated */
+    projectTaskId?: string;
+    /** Original message text for this task's message group (preserves user input) */
+    originalMessage?: string;
+}
+/**
+ * Status of a project task based on its linked intent tasks.
+ */
+export interface ProjectTaskStatus {
+    /** Project task ID */
+    projectTaskId: string;
+    /** Total linked intent tasks */
+    totalTasks: number;
+    /** Completed intent tasks */
+    completedTasks: number;
+    /** Whether all linked tasks are done */
+    allCompleted: boolean;
+    /** List of linked task summaries */
+    tasks: IntentTaskSummary[];
+}
+/**
+ * Determines whether a text segment represents an actionable intent
+ * that should become a task (vs. a question, greeting, acknowledgment, or discussion).
+ *
+ * @param text - The text segment to evaluate
+ * @returns true if the text is actionable and should become a task
+ */
+export declare function isActionableIntent(text: string): boolean;
+/**
+ * Heuristic rules for auto-classifying intent level.
+ * Returns L0 for simple queries/lookups, L1 for standard tasks, L2 for complex multi-step.
+ *
+ * @param intent - User intent text
+ * @returns Classified intent level
+ */
+export declare function classifyIntentLevel(intent: string): IntentLevel;
+/**
+ * Heuristic rules for auto-classifying intent category.
+ * Uses prioritized pattern matching — first match wins.
+ *
+ * @param intent - User intent text
+ * @returns Classified intent category
+ */
+export declare function classifyIntentCategory(intent: string): IntentCategory;
+/**
+ * Decompose a user message into multiple individual actionable intents.
+ *
+ * Three-phase pipeline:
+ * 1. **Split**: Single-pass regex split on conjunctions and sequential markers.
+ * 2. **Filter**: Remove non-actionable segments (questions, greetings, feedback, filler).
+ * 3. **Classify**: Independently classify each actionable segment by level and category.
+ *
+ * @param message - The full user message
+ * @returns DecomposeResult with the original message and extracted actionable intents.
+ *          Returns empty intents array if no actionable content is found.
+ *
+ * @example
+ * ```typescript
+ * const result = decomposeIntents('Search for abc then make it into a PDF');
+ * // result.intents = [
+ * //   { intent: 'Search for abc', level: 'L0', category: 'query' },
+ * //   { intent: 'make it into a PDF', level: 'L1', category: 'code_change' },
+ * // ]
+ *
+ * // Non-actionable messages return empty
+ * const result2 = decomposeIntents('Looks good, thanks!');
+ * // result2.intents = []
+ * ```
+ */
+export declare function decomposeIntents(message: string): DecomposeResult;
+//# sourceMappingURL=intent-task.types.d.ts.map

package/dist/backend/backend/src/types/intent-task.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent-task.types.d.ts","sourceRoot":"","sources":["../../../../../backend/src/types/intent-task.types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAE7C;;GAEG;AACH,MAAM,MAAM,cAAc,GACtB,OAAO,GACP,aAAa,GACb,WAAW,GACX,YAAY,GACZ,UAAU,GACV,QAAQ,GACR,UAAU,GACV,eAAe,GACf,OAAO,CAAC;AAMZ;;GAEG;AACH,MAAM,MAAM,gBAAgB,GACxB,SAAS,GACT,YAAY,GACZ,aAAa,GACb,QAAQ,GACR,WAAW,GACX,QAAQ,GACR,WAAW,CAAC;AAEhB;;GAEG;AACH,MAAM,MAAM,SAAS,GACjB,SAAS,GACT,WAAW,GACX,QAAQ,GACR,WAAW,CAAC;AAEhB;;GAEG;AACH,MAAM,MAAM,QAAQ,GAChB,UAAU,GACV,WAAW,GACX,YAAY,GACZ,YAAY,GACZ,SAAS,GACT,YAAY,CAAC;AAMjB;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACvB,6BAA6B;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,oBAAoB;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,wBAAwB;IACxB,IAAI,EAAE,QAAQ,CAAC;IACf,yDAAyD;IACzD,KAAK,EAAE,MAAM,CAAC;IACd,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,gEAAgE;IAChE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,wDAAwD;IACxD,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,iDAAiD;IACjD,WAAW,EAAE,MAAM,CAAC;IACpB,mDAAmD;IACnD,YAAY,EAAE,MAAM,CAAC;IACrB,8EAA8E;IAC9E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB,4BAA4B;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,qBAAqB;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,oCAAoC;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,uCAAuC;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,qBAAqB;IACrB,MAAM,EAAE,SAAS,CAAC;IAClB,yCAAyC;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,uCAAuC;IACvC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,0CAA0C;IAC1C,gBAAgB,EAAE,MAAM,CAAC;IACzB,2CAA2C;IAC3C,iBAAiB,EAAE,MAAM,CAAC;IAC1B,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,uEAAuE;IACvE,SAAS,EAAE,MAAM,CAAC;IAClB,4BAA4B;IAC5B,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,8BAA8B;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,6BAA6B;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,8EAA8E;IAC9E,SAAS,EAAE,MAAM,CAAC;IAClB,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,kCAAkC;IAClC,KAAK,EAAE,WAAW,CAAC;IACnB,sBAAsB;IACtB,QAAQ,EAAE,cAAc,CAAC;IACzB,+BAA+B;IAC/B,MAAM,EAAE,gBAAgB,CAAC;IACzB,iCAAiC;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,0CAA0C;IAC1C,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,8BAA8B;IAC9B,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,qBAAqB;IACrB,IAAI,EAAE,OAAO,EAAE,CAAC;IAChB,8CAA8C;IAC9C,gBAAgB,EAAE,MAAM,CAAC;IACzB,+CAA+C;IAC/C,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iCAAiC;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,yEAAyE;IACzE,cAAc,EAAE,MAAM,CAAC;IACvB,8BAA8B;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,yDAAyD;IACzD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kCAAkC;IAClC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,0DAA0D;IAC1D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;CACf;AAMD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,uCAAuC;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,KAAK,EAAE,WAAW,CAAC;IACnB,+BAA+B;IAC/B,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,gCAAgC;IAChC,eAAe,EAAE,MAAM,CAAC;IACxB,wCAAwC;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,kCAAkC;IAClC,OAAO,EAAE,gBAAgB,EAAE,CAAC;CAC7B;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,mDAAmD;IACnD,SAAS,EAAE,MAAM,CAAC;IAClB,0DAA0D;IAC1D,eAAe,EAAE,MAAM,CAAC;IACxB,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,KAAK,EAAE,iBAAiB,EAAE,CAAC;IAC3B,8CAA8C;IAC9C,cAAc,EAAE,MAAM,CAAC;IACvB,0CAA0C;IAC1C,UAAU,EAAE,MAAM,CAAC;CACpB;AAMD;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,8BAA8B;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,2DAA2D;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,8BAA8B;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oBAAoB;IACpB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,yCAAyC;IACzC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,+BAA+B;IAC/B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,0CAA0C;IAC1C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,yCAAyC;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,qDAAqD;IACrD,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,+DAA+D;IAC/D,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC,iBAAiB;IACjB,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,6DAA6D;IAC7D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+BAA+B;IAC/B,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,uBAAuB;IACvB,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,uCAAuC;IACvC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oCAAoC;IACpC,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,+BAA+B;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;GAGG;AACH,MAAM,WAAW,0BAA0B;IACzC,+BAA+B;IAC/B,KAAK,EAAE,qBAAqB,EAAE,CAAC;IAC/B,0DAA0D;IAC1D,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,sCAAsC;IACtC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,gBAAgB;IAChB,IAAI,EAAE,QAAQ,CAAC;IACf,2BAA2B;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,kCAAkC;IAClC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mCAAmC;IACnC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,+BAA+B;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8EAA8E;IAC9E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,wBAAwB;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,cAAc;IACd,EAAE,EAAE,MAAM,CAAC;IACX,8BAA8B;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,qCAAqC;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,uBAAuB;IACvB,KAAK,EAAE,WAAW,CAAC;IACnB,eAAe;IACf,QAAQ,EAAE,cAAc,CAAC;IACzB,qBAAqB;IACrB,MAAM,EAAE,gBAAgB,CAAC;IACzB,mBAAmB;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,wBAAwB;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,qBAAqB;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,oCAAoC;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,4BAA4B;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,8BAA8B;IAC9B,cAAc,EAAE,MAAM,CAAC;IACvB,wBAAwB;IACxB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,iCAAiC;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,gCAAgC;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,oCAAoC;IACpC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iFAAiF;IACjF,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,sBAAsB;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,gCAAgC;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,6BAA6B;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,wCAAwC;IACxC,YAAY,EAAE,OAAO,CAAC;IACtB,oCAAoC;IACpC,KAAK,EAAE,iBAAiB,EAAE,CAAC;CAC5B;AAqCD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAaxD;AAMD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAkC/D;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CA8BrE;AAeD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,CAmDjE"}

package/dist/backend/backend/src/types/intent-task.types.js

@@ -0,0 +1,231 @@
+/**
+ * Intent Task Types — V2
+ *
+ * Defines the dual-layer Intent Task System with multi-intent decomposition:
+ * - Intent Layer: User messages decomposed into multiple intents, each classified by complexity (L0/L1/L2)
+ * - Execution Layer: Task -> Run -> Span model for tracking work
+ * - Association Layer: Schedule follow-up and project task linkage
+ *
+ * Key v2 change: One chat message can produce multiple intent tasks.
+ * Tasks are grouped by messageId and displayed as a todo list.
+ *
+ * Token usage binds to task_id + run_id via TokenUsageService integration.
+ *
+ * @module types/intent-task
+ */
+// =============================================================================
+// Actionability Detection
+// =============================================================================
+/**
+ * Patterns that indicate a message is NOT actionable (should not become a task).
+ * These cover greetings, acknowledgments, questions, feedback, opinions, and filler.
+ */
+const NON_ACTIONABLE_PATTERNS = [
+    // Greetings / pleasantries
+    /^(hi|hello|hey|yo|sup|good\s+(morning|afternoon|evening|night)|thanks|thank\s+you|thx|cheers|bye|goodbye|welcome\s+back)\b/i,
+    // Pure acknowledgments
+    /^(ok|okay|sure|got\s+it|understood|roger|ack|yep|yup|yeah|yes|no|nah|nope|alright|right|fine|great|perfect|awesome|cool|nice|good\s+(job|work)|looks?\s+good|lgtm|approved|noted|agreed|sounds\s+good|will\s+do|on\s+it)\s*[.!]?$/i,
+    // Pure questions with no action request (short, interrogative-only)
+    /^(what|where|when|who|which|how|why|is|are|was|were|can|could|do|does|did|has|have|will|would|should)\b.{0,60}\?\s*$/i,
+    // Opinions / discussion / thinking out loud (no imperative verb)
+    /^(i\s+think|i\s+believe|i\s+feel|i\s+wonder|maybe\s+we|perhaps|it\s+seems|it\s+looks\s+like|fyi|btw|by\s+the\s+way|just\s+letting\s+you\s+know|heads\s+up|for\s+your\s+info)\b/i,
+    // Status updates / reports (not requests)
+    /^(i\s+(just|already)\s+(did|finished|completed|fixed|deployed|updated|pushed|merged|committed)|done\s+with|finished|completed|all\s+(set|done|good))\b/i,
+    // Emoji-only or very short non-actionable
+    /^[\p{Emoji}\s.,!?:;]+$/u,
+];
+/**
+ * Action verbs that indicate a message contains an actionable intent.
+ * Used as a positive signal when non-actionable patterns don't match.
+ */
+const ACTION_VERB_PATTERN = /\b(fix|build|create|deploy|implement|add|update|delete|remove|write|read|check|test|run|make|send|set\s+up|configure|install|download|upload|convert|transform|generate|export|import|refactor|migrate|upgrade|optimize|search|find|move|copy|rename|clean\s*up|set|start|stop|restart|enable|disable|schedule|assign|delegate|review|audit|analyze|investigate|research|explore|design|plan|document|monitor|track|debug|trace|patch|revert|rollback|merge|push|pull|commit|release|publish|integrate|connect|disconnect|setup|tear\s*down|provision|scale|backup|restore)\b/i;
+/**
+ * Minimum character count for a segment to be a meaningful intent.
+ * Very short fragments like "ok" or "no" are not tasks.
+ */
+const MIN_ACTIONABLE_CHARS = 3;
+/**
+ * Determines whether a text segment represents an actionable intent
+ * that should become a task (vs. a question, greeting, acknowledgment, or discussion).
+ *
+ * @param text - The text segment to evaluate
+ * @returns true if the text is actionable and should become a task
+ */
+export function isActionableIntent(text) {
+    const trimmed = text.trim();
+    // Too short to be meaningful
+    if (trimmed.length < MIN_ACTIONABLE_CHARS)
+        return false;
+    // Check non-actionable patterns first (fast reject)
+    for (const pattern of NON_ACTIONABLE_PATTERNS) {
+        if (pattern.test(trimmed))
+            return false;
+    }
+    // Must contain at least one action verb to be considered a task
+    return ACTION_VERB_PATTERN.test(trimmed);
+}
+// =============================================================================
+// Classification Helpers
+// =============================================================================
+/**
+ * Heuristic rules for auto-classifying intent level.
+ * Returns L0 for simple queries/lookups, L1 for standard tasks, L2 for complex multi-step.
+ *
+ * @param intent - User intent text
+ * @returns Classified intent level
+ */
+export function classifyIntentLevel(intent) {
+    const lower = intent.toLowerCase();
+    const wordCount = intent.split(/\s+/).length;
+    // L0: Simple lookups, status checks, single-tool operations
+    const l0Patterns = [
+        /^(what|where|when|who|how|is|are|can|does|do|show|list|get|check|find)\b/i,
+        /\?$/,
+        /\b(status|version|health|uptime|count|list)\b/i,
+    ];
+    if (wordCount <= 12 && l0Patterns.some((p) => p.test(lower))) {
+        return 'L0';
+    }
+    // L2: Complex multi-agent, multi-step, or cross-system tasks
+    const l2Patterns = [
+        // Verb + complex noun = feature-level work
+        /\b(implement|build|create|develop|design|architect|refactor)\b.*\b(feature|system|service|module|component|pipeline|workflow|framework|infrastructure)\b/i,
+        // Deployment / migration / upgrade (multi-step by nature)
+        /\b(deploy|migrate|upgrade|provision)\b.*\b(to|from|environment|server|cluster|staging|production)\b/i,
+        // Explicit multi-step language
+        /\bmulti[- ]?(agent|step|phase|stage)\b/i,
+        /\b(coordinate|orchestrate|delegate|parallelize)\b/i,
+        // End-to-end or full-stack scope
+        /\b(end[- ]to[- ]end|full[- ]stack|e2e|integration)\b.*\b(test|setup|implementation)\b/i,
+        // Sprint / project level work
+        /\b(sprint|milestone|epic|project)\b.*\b(deliver|complete|implement|execute)\b/i,
+    ];
+    if (l2Patterns.some((p) => p.test(lower)) || wordCount > 35) {
+        return 'L2';
+    }
+    // L1: Standard single-agent tasks
+    return 'L1';
+}
+/**
+ * Heuristic rules for auto-classifying intent category.
+ * Uses prioritized pattern matching — first match wins.
+ *
+ * @param intent - User intent text
+ * @returns Classified intent category
+ */
+export function classifyIntentCategory(intent) {
+    const lower = intent.toLowerCase();
+    // Debugging: bug fixes, error investigation, tracing
+    if (/\b(fix|bug|error|crash|broken|issue|debug|trace|stack\s*trace|exception|segfault|panic|hang|leak|regression|flaky)\b/.test(lower))
+        return 'debugging';
+    // Deployment: releases, CI/CD, infrastructure (require deployment-specific context)
+    if (/\b(deploy|staging|production|docker|kubernetes|k8s|helm|terraform|ansible|nginx|container|image|rollback|rollout)\b/.test(lower))
+        return 'deployment';
+    if (/\b(release)\b/.test(lower) && !/\b(announce|notify|tell|inform|message|communicate)\b/.test(lower))
+        return 'deployment';
+    if (/\b(ci|cd)\b/.test(lower) && /\b(pipeline|build|run|trigger|fix)\b/.test(lower))
+        return 'deployment';
+    // Review: code review, PR, audit
+    if (/\b(review|pr\b|pull\s+request|code\s+review|audit|approve|reject|lgtm)\b/.test(lower))
+        return 'review';
+    // Research: investigation, exploration, analysis, comparison
+    if (/\b(research|investigate|explore|analyze|compare|evaluate|benchmark|measure|profile|survey|study)\b/.test(lower))
+        return 'research';
+    // Planning: strategy, design, architecture, roadmap
+    if (/\b(plan|roadmap|strategy|design|architect|spec|specification|rfc|proposal|estimate|prioritize|schedule|timeline|milestone)\b/.test(lower))
+        return 'planning';
+    // Communication: messaging, notifications, announcements
+    if (/\b(message|notify|slack|email|communicate|tell\s|announce|broadcast|ping|alert|report\s+to|inform|update\s+the\s+team)\b/.test(lower))
+        return 'communication';
+    // Code change: implementation, modification, creation (broad — checked after more specific categories)
+    if (/\b(implement|code|write|add|update|modify|refactor|create|build|develop|rename|move|copy|delete|remove|clean\s*up|optimize|improve|enhance|extend|extract|inline|merge|split|convert|transform|generate|scaffold|bootstrap|set\s*up|configure|install|integrate|connect|wire|hook\s*up|enable|disable)\b/.test(lower))
+        return 'code_change';
+    // Query: information retrieval, status checks, lookups
+    if (/\b(what|where|when|who|which|how|show|list|get|status|check|find|search|look\s*up|count|describe|explain)\b/.test(lower))
+        return 'query';
+    return 'other';
+}
+// =============================================================================
+// Decomposition Helpers
+// =============================================================================
+/**
+ * Combined regex that splits on intent boundaries in a single pass.
+ * Matches: "then", "after that", "and then", "and also", "also", "plus",
+ * numbered lists ("1. ... 2. ..."), semicolons, and "and/," before action verbs.
+ *
+ * Uses non-capturing groups and alternation with priority ordering.
+ */
+const SPLIT_REGEX = /\s*(?:\band\s+then\b|\bafter\s+that\b|\band\s+also\b|\bthen\b|\balso\b|\bplus\b|\s*;\s*|\s*\d+\)\s*|\s*\d+\.\s+(?=[A-Z])|(?:,\s*|\s+and\s+)(?=(?:search|find|fix|build|create|deploy|implement|add|update|delete|remove|write|read|check|test|run|make|do|send|set\s*up|configure|install|download|upload|convert|transform|generate|export|import|review|audit|analyze|investigate|research|design|plan|monitor|debug|refactor|migrate|optimize|clean|start|stop|restart|enable|disable|schedule|assign|push|pull|commit|release|merge|connect|move|copy|rename|backup|restore)\b))\s*/i;
+/**
+ * Decompose a user message into multiple individual actionable intents.
+ *
+ * Three-phase pipeline:
+ * 1. **Split**: Single-pass regex split on conjunctions and sequential markers.
+ * 2. **Filter**: Remove non-actionable segments (questions, greetings, feedback, filler).
+ * 3. **Classify**: Independently classify each actionable segment by level and category.
+ *
+ * @param message - The full user message
+ * @returns DecomposeResult with the original message and extracted actionable intents.
+ *          Returns empty intents array if no actionable content is found.
+ *
+ * @example
+ * ```typescript
+ * const result = decomposeIntents('Search for abc then make it into a PDF');
+ * // result.intents = [
+ * //   { intent: 'Search for abc', level: 'L0', category: 'query' },
+ * //   { intent: 'make it into a PDF', level: 'L1', category: 'code_change' },
+ * // ]
+ *
+ * // Non-actionable messages return empty
+ * const result2 = decomposeIntents('Looks good, thanks!');
+ * // result2.intents = []
+ * ```
+ */
+export function decomposeIntents(message) {
+    const trimmed = message.trim();
+    if (!trimmed) {
+        return {
+            originalMessage: message,
+            messageId: '',
+            intents: [],
+        };
+    }
+    // Phase 1: Split on intent boundaries (single-pass)
+    const rawSegments = trimmed.split(SPLIT_REGEX)
+        .map((s) => s.trim())
+        .filter((s) => s.length >= MIN_ACTIONABLE_CHARS);
+    // Phase 2: Filter to actionable intents only
+    const actionable = rawSegments.filter((seg) => isActionableIntent(seg));
+    // If splitting produced no actionable segments, check if the whole message is actionable
+    if (actionable.length === 0) {
+        if (isActionableIntent(trimmed)) {
+            return {
+                originalMessage: message,
+                messageId: '',
+                intents: [{
+                        intent: trimmed,
+                        level: classifyIntentLevel(trimmed),
+                        category: classifyIntentCategory(trimmed),
+                    }],
+            };
+        }
+        // Entire message is non-actionable → no tasks
+        return {
+            originalMessage: message,
+            messageId: '',
+            intents: [],
+        };
+    }
+    // Phase 3: Classify each actionable segment
+    const intents = actionable.map((seg) => ({
+        intent: seg,
+        level: classifyIntentLevel(seg),
+        category: classifyIntentCategory(seg),
+    }));
+    return {
+        originalMessage: message,
+        messageId: '', // Service will generate the UUID
+        intents,
+    };
+}
+//# sourceMappingURL=intent-task.types.js.map

package/dist/backend/backend/src/types/intent-task.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent-task.types.js","sourceRoot":"","sources":["../../../../../backend/src/types/intent-task.types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAmYH,gFAAgF;AAChF,0BAA0B;AAC1B,gFAAgF;AAEhF;;;GAGG;AACH,MAAM,uBAAuB,GAAa;IACxC,2BAA2B;IAC3B,6HAA6H;IAC7H,uBAAuB;IACvB,oOAAoO;IACpO,oEAAoE;IACpE,uHAAuH;IACvH,iEAAiE;IACjE,iLAAiL;IACjL,0CAA0C;IAC1C,yJAAyJ;IACzJ,0CAA0C;IAC1C,yBAAyB;CAC1B,CAAC;AAEF;;;GAGG;AACH,MAAM,mBAAmB,GAAG,gjBAAgjB,CAAC;AAE7kB;;;GAGG;AACH,MAAM,oBAAoB,GAAG,CAAC,CAAC;AAE/B;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAY;IAC7C,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;IAE5B,6BAA6B;IAC7B,IAAI,OAAO,CAAC,MAAM,GAAG,oBAAoB;QAAE,OAAO,KAAK,CAAC;IAExD,oDAAoD;IACpD,KAAK,MAAM,OAAO,IAAI,uBAAuB,EAAE,CAAC;QAC9C,IAAI,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC;YAAE,OAAO,KAAK,CAAC;IAC1C,CAAC;IAED,gEAAgE;IAChE,OAAO,mBAAmB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AAC3C,CAAC;AAED,gFAAgF;AAChF,yBAAyB;AACzB,gFAAgF;AAEhF;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAc;IAChD,MAAM,KAAK,GAAG,MAAM,CAAC,WAAW,EAAE,CAAC;IACnC,MAAM,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC;IAE7C,4DAA4D;IAC5D,MAAM,UAAU,GAAG;QACjB,2EAA2E;QAC3E,KAAK;QACL,gDAAgD;KACjD,CAAC;IACF,IAAI,SAAS,IAAI,EAAE,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;QAC7D,OAAO,IAAI,CAAC;IACd,CAAC;IAED,6DAA6D;IAC7D,MAAM,UAAU,GAAG;QACjB,2CAA2C;QAC3C,2JAA2J;QAC3J,0DAA0D;QAC1D,sGAAsG;QACtG,+BAA+B;QAC/B,yCAAyC;QACzC,oDAAoD;QACpD,iCAAiC;QACjC,wFAAwF;QACxF,8BAA8B;QAC9B,gFAAgF;KACjF,CAAC;IACF,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,SAAS,GAAG,EAAE,EAAE,CAAC;QAC5D,OAAO,IAAI,CAAC;IACd,CAAC;IAED,kCAAkC;IAClC,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,sBAAsB,CAAC,MAAc;IACnD,MAAM,KAAK,GAAG,MAAM,CAAC,WAAW,EAAE,CAAC;IAEnC,qDAAqD;IACrD,IAAI,sHAAsH,CAAC,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,WAAW,CAAC;IAE3J,oFAAoF;IACpF,IAAI,qHAAqH,CAAC,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,YAAY,CAAC;IAC3J,IAAI,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,uDAAuD,CAAC,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,YAAY,CAAC;IAC7H,IAAI,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,sCAAsC,CAAC,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,YAAY,CAAC;IAEzG,iCAAiC;IACjC,IAAI,0EAA0E,CAAC,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,QAAQ,CAAC;IAE5G,6DAA6D;IAC7D,IAAI,oGAAoG,CAAC,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,UAAU,CAAC;IAExI,oDAAoD;IACpD,IAAI,8HAA8H,CAAC,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,UAAU,CAAC;IAElK,yDAAyD;IACzD,IAAI,0HAA0H,CAAC,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,eAAe,CAAC;IAEnK,uGAAuG;IACvG,IAAI,0SAA0S,CAAC,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,aAAa,CAAC;IAEjV,uDAAuD;IACvD,IAAI,6GAA6G,CAAC,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,OAAO,CAAC;IAE9I,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,gFAAgF;AAChF,wBAAwB;AACxB,gFAAgF;AAEhF;;;;;;GAMG;AACH,MAAM,WAAW,GAAG,0jBAA0jB,CAAC;AAE/kB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,gBAAgB,CAAC,OAAe;IAC9C,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAC/B,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO;YACL,eAAe,EAAE,OAAO;YACxB,SAAS,EAAE,EAAE;YACb,OAAO,EAAE,EAAE;SACZ,CAAC;IACJ,CAAC;IAED,oDAAoD;IACpD,MAAM,WAAW,GAAG,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC;SAC3C,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;SACpB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,IAAI,oBAAoB,CAAC,CAAC;IAEnD,6CAA6C;IAC7C,MAAM,UAAU,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC;IAExE,yFAAyF;IACzF,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC5B,IAAI,kBAAkB,CAAC,OAAO,CAAC,EAAE,CAAC;YAChC,OAAO;gBACL,eAAe,EAAE,OAAO;gBACxB,SAAS,EAAE,EAAE;gBACb,OAAO,EAAE,CAAC;wBACR,MAAM,EAAE,OAAO;wBACf,KAAK,EAAE,mBAAmB,CAAC,OAAO,CAAC;wBACnC,QAAQ,EAAE,sBAAsB,CAAC,OAAO,CAAC;qBAC1C,CAAC;aACH,CAAC;QACJ,CAAC;QACD,8CAA8C;QAC9C,OAAO;YACL,eAAe,EAAE,OAAO;YACxB,SAAS,EAAE,EAAE;YACb,OAAO,EAAE,EAAE;SACZ,CAAC;IACJ,CAAC;IAED,4CAA4C;IAC5C,MAAM,OAAO,GAAuB,UAAU,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QAC3D,MAAM,EAAE,GAAG;QACX,KAAK,EAAE,mBAAmB,CAAC,GAAG,CAAC;QAC/B,QAAQ,EAAE,sBAAsB,CAAC,GAAG,CAAC;KACtC,CAAC,CAAC,CAAC;IAEJ,OAAO;QACL,eAAe,EAAE,OAAO;QACxB,SAAS,EAAE,EAAE,EAAE,iCAAiC;QAChD,OAAO;KACR,CAAC;AACJ,CAAC"}

package/dist/backend/backend/src/types/memory.types.d.ts

@@ -11,6 +11,19 @@
  * Categories for role knowledge entries
  */
 export type RoleKnowledgeCategory = 'best-practice' | 'anti-pattern' | 'tool-usage' | 'workflow';
+/**
+ * Memory type classification — determines how a memory entry is used.
+ *
+ * Different memory types serve different purposes and should be injected
+ * differently (or not at all) into agent prompts:
+ *
+ * - **procedural**: How to do things — injected into worker prompts to guide execution
+ * - **risk**: What to avoid — injected early in prompts as warnings
+ * - **preference**: Style/approach preferences — injected with low weight, may be overridden
+ * - **domain**: Business/architecture facts — injected but flagged for freshness verification
+ * - **performance**: Agent strengths/weaknesses — injected into TL/orchestrator prompts for scheduling, NOT into worker prompts
+ */
+export type MemoryType = 'procedural' | 'risk' | 'preference' | 'domain' | 'performance';
 /**
  * A single piece of role-specific knowledge learned by an agent
  *
@@ -32,6 +45,12 @@ export interface RoleKnowledgeEntry {
     id: string;
     /** Category of knowledge */
     category: RoleKnowledgeCategory;
+    /**
+     * Memory type — determines injection strategy.
+     * Risk memories are injected as early warnings. Performance memories go to TL/orchestrator only.
+     * Defaults to 'procedural' for backward compatibility with existing entries.
+     */
+    memoryType?: MemoryType;
     /** The actual knowledge content */
     content: string;
     /** Task/Ticket ID where this was learned (optional) */