turboflux 1.0.0

package/dist/shared/agentTypes.d.ts

@@ -0,0 +1,227 @@
+export type AgentMode = 'vibe' | 'plan';
+export type ApprovalPolicy = 'ask' | 'agent' | 'full';
+export type CapabilityProfile = 'read-only' | 'workspace-write' | 'danger-full-access';
+export type LegacyApprovalPolicy = 'request' | 'auto';
+export declare const REASONING_EFFORTS: readonly ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+export type ReasoningEffort = typeof REASONING_EFFORTS[number];
+export interface NativeReasoningConfig {
+    enabled?: boolean;
+    effort?: ReasoningEffort;
+    budgetTokens?: number;
+}
+export type ContextPolicyMode = 'normal' | 'qualityFirst';
+export type TaskPriority = 'major' | 'medium' | 'minor';
+export type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed';
+export type AgentRunPhase = 'idle' | 'thinking' | 'tool_running' | 'awaiting_approval' | 'awaiting_input' | 'paused' | 'aborting' | 'recoverable_error' | 'completed';
+export interface AgentRunState {
+    phase: AgentRunPhase;
+    startedAt?: number;
+    updatedAt: number;
+    detail?: string;
+    activeTool?: string;
+    recoverable?: boolean;
+}
+export type ToolCategory = 'read' | 'write' | 'execute' | 'communicate' | 'manage';
+export interface AgentTool {
+    name: string;
+    description: string;
+    category: ToolCategory;
+    parameters: ToolParameter[];
+    isReadOnly: boolean;
+    isDestructive: boolean;
+    isConcurrencySafe: boolean;
+    requiredMode?: AgentMode[];
+    inputSchema?: Record<string, unknown>;
+}
+export interface ToolParameter {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object';
+    description: string;
+    required: boolean;
+    enum?: string[];
+    default?: unknown;
+    schema?: Record<string, unknown>;
+}
+export interface TaskNode {
+    id: string;
+    title: string;
+    description: string;
+    priority: TaskPriority;
+    status: TaskStatus;
+    parentId: string | null;
+    children: string[];
+    dependencies: string[];
+    order: number;
+    toolUseId?: string;
+    progress: number;
+    createdAt: number;
+    updatedAt: number;
+    startedAt?: number;
+    completedAt?: number;
+    error?: string;
+    metadata?: {
+        estimatedDuration?: string;
+        relatedFiles?: string[];
+        testResults?: string;
+        errorLog?: string;
+        relatedIssue?: string;
+        [key: string]: unknown;
+    };
+}
+export interface AgentTurn {
+    id: string;
+    role: 'user' | 'assistant' | 'system' | 'tool_result';
+    content: string;
+    timestamp: number;
+    toolCalls?: ToolCall[];
+    toolResults?: ToolResult[];
+    metadata?: {
+        model?: string;
+        tokens?: TokenUsage;
+        duration?: number;
+        mode?: AgentMode;
+        reasoningEnabled?: boolean;
+        reasoningEffort?: ReasoningEffort;
+        thinking?: ThinkingTrace;
+        rawReasoningPayload?: RawReasoningPayload;
+        interrupted?: boolean;
+        internal?: boolean;
+        internalKind?: string;
+        attachments?: AgentAttachment[];
+        runtimeContext?: string;
+    };
+}
+export interface AgentAttachment {
+    id: string;
+    type: 'image';
+    path: string;
+    mime: string;
+    filename: string;
+    size: number;
+}
+export interface TokenUsage {
+    input?: number;
+    output?: number;
+    cached?: number;
+    total?: number;
+    source?: 'provider' | 'unknown';
+}
+export interface OpenAIReasoningBlock {
+    type: 'reasoning';
+    reasoning: string;
+}
+export interface RawReasoningPayload {
+    provider: 'anthropic' | 'openai-compatible';
+    blocks: AnthropicThinkingBlock[];
+    reasoningContent?: string;
+}
+export interface AnthropicThinkingBlock {
+    type: 'thinking' | 'redacted_thinking';
+    thinking?: string;
+    signature?: string;
+    data?: string;
+}
+export type ThinkingStage = 'problem_framing' | 'evidence_gathering' | 'hypothesis_testing' | 'verification' | 'conclusion';
+export type ThinkingEvidenceLevel = 'none' | 'broad' | 'strong' | 'multi_source';
+export type ThinkingVerificationStatus = 'unverified' | 'partial' | 'verified' | 'contested';
+export interface ThinkingTrace {
+    content: string;
+    isStreaming?: boolean;
+    status?: 'streaming' | 'complete' | 'interrupted' | 'redacted';
+    source?: 'provider' | 'fallback';
+    tokenCount?: number;
+    startedAt?: number;
+    effort?: ReasoningEffort;
+    stage?: ThinkingStage;
+    evidenceLevel?: ThinkingEvidenceLevel;
+    verificationStatus?: ThinkingVerificationStatus;
+    hadAlternatives?: boolean;
+    hasToolBackedVerification?: boolean;
+    durationMs?: number;
+}
+export interface ToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+}
+export interface ChangeSummary {
+    path: string;
+    operation: 'write' | 'edit' | 'delete';
+    addedLines?: number;
+    removedLines?: number;
+    totalLines?: number;
+    preview?: string;
+    oldPreview?: string;
+    before?: string;
+    after?: string;
+    diffStatus?: 'complete' | 'snapshot-too-large' | 'postimage-unavailable';
+    beforeBytes?: number;
+    afterBytes?: number;
+}
+export interface ToolResult {
+    toolCallId: string;
+    name: string;
+    output: string;
+    isError: boolean;
+    errorKind?: 'validation' | 'permission' | 'environment' | 'execution' | 'timeout' | 'abort';
+    changeSummary?: ChangeSummary;
+}
+export interface AgentSession {
+    id: string;
+    mode: AgentMode;
+    turns: AgentTurn[];
+    currentTaskId: string | null;
+    createdAt: number;
+    updatedAt: number;
+    workspacePath?: string;
+    workspaceName?: string;
+    totalTokens: {
+        input: number;
+        output: number;
+    };
+}
+export interface AgentConfig {
+    mode: AgentMode;
+    approvalPolicy?: ApprovalPolicy;
+    capabilityProfile?: CapabilityProfile;
+    temperature: number;
+    maxTokens: number;
+    maxTurns?: number;
+    contextWindow?: number;
+    contextPolicy?: ContextPolicyMode;
+    conversationId?: string;
+    workspacePath?: string;
+    workspaceName?: string;
+    systemPromptOverride?: string;
+    appendSystemPrompt?: string;
+    profileSystemPrompt?: string;
+    disabledTools?: string[];
+    enabledSkills?: Array<{
+        id: string;
+        name: string;
+        command: string;
+        description: string;
+        capabilities?: {
+            can?: string[];
+            cannot?: string[];
+        };
+        principles?: string[];
+        systemPrompt?: string;
+    }>;
+    shell?: string;
+    gitEnabled?: boolean;
+}
+export declare const TASK_ID_PREFIXES: Record<TaskPriority, string>;
+export declare const MODE_LABELS: Record<AgentMode, string>;
+export declare const MODE_DESCRIPTIONS: Record<AgentMode, string>;
+export declare const APPROVAL_POLICY_LABELS: Record<ApprovalPolicy, string>;
+export declare const APPROVAL_POLICY_DESCRIPTIONS: Record<ApprovalPolicy, string>;
+export declare const CAPABILITY_PROFILE_LABELS: Record<CapabilityProfile, string>;
+export declare const CAPABILITY_PROFILE_DESCRIPTIONS: Record<CapabilityProfile, string>;
+export declare function normalizeApprovalPolicy(value: unknown, fallback?: ApprovalPolicy): ApprovalPolicy;
+export declare function normalizeCapabilityProfile(value: unknown, fallback?: CapabilityProfile): CapabilityProfile;
+export declare function resolveCapabilityProfileForApproval(approvalPolicy: ApprovalPolicy, capabilityProfile: unknown, fallback?: CapabilityProfile): CapabilityProfile;
+export declare function isTerminalStatus(status: TaskStatus): boolean;
+export declare function generateTaskId(priority: TaskPriority): string;
+export declare function generateTurnId(): string;
+export declare function generateSessionId(): string;

package/dist/shared/agentTypes.js

@@ -0,0 +1,79 @@
+export const REASONING_EFFORTS = ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+export const TASK_ID_PREFIXES = {
+    major: 'M',
+    medium: 'D',
+    minor: 'T',
+};
+export const MODE_LABELS = {
+    vibe: 'Vibe',
+    plan: 'Plan',
+};
+export const MODE_DESCRIPTIONS = {
+    vibe: '快速执行模式 - AI 自主完成从规划到实现的全过程',
+    plan: '规划模式 - 先制定详细计划，用户审批后执行',
+};
+export const APPROVAL_POLICY_LABELS = {
+    ask: 'Request approval',
+    agent: 'Approve low risk',
+    full: 'Full access',
+};
+export const APPROVAL_POLICY_DESCRIPTIONS = {
+    ask: 'Ask before file changes, commands, MCP tools, and external actions.',
+    agent: 'Continue with low-risk workspace actions and ask only when risk is detected.',
+    full: 'Run without approval prompts or workspace restrictions; explicit deny rules remain active.',
+};
+export const CAPABILITY_PROFILE_LABELS = {
+    'read-only': 'Read only',
+    'workspace-write': 'Workspace write',
+    'danger-full-access': 'Danger: full access',
+};
+export const CAPABILITY_PROFILE_DESCRIPTIONS = {
+    'read-only': 'Read files inside the workspace; block writes and commands.',
+    'workspace-write': 'Read and write inside the workspace; block host commands and external paths.',
+    'danger-full-access': 'Allow host commands and paths outside the workspace within the approval policy.',
+};
+export function normalizeApprovalPolicy(value, fallback = 'ask') {
+    if (value === 'ask' || value === 'agent' || value === 'full')
+        return value;
+    if (value === 'request')
+        return 'ask';
+    if (value === 'auto')
+        return 'agent';
+    return fallback;
+}
+export function normalizeCapabilityProfile(value, fallback = 'workspace-write') {
+    if (value === 'read-only' || value === 'workspace-write' || value === 'danger-full-access')
+        return value;
+    return fallback;
+}
+export function resolveCapabilityProfileForApproval(approvalPolicy, capabilityProfile, fallback = 'workspace-write') {
+    if (approvalPolicy === 'full')
+        return 'danger-full-access';
+    return normalizeCapabilityProfile(capabilityProfile, fallback);
+}
+export function isTerminalStatus(status) {
+    return status === 'completed' || status === 'failed';
+}
+export function generateTaskId(priority) {
+    const prefix = TASK_ID_PREFIXES[priority];
+    let suffix;
+    try {
+        if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+            suffix = crypto.randomUUID().replace(/-/g, '').slice(0, 12);
+        }
+        else {
+            suffix = `${Date.now().toString(36)}-${Math.random().toString(36).substring(2, 10)}`;
+        }
+    }
+    catch {
+        suffix = `${Date.now().toString(36)}-${Math.random().toString(36).substring(2, 10)}`;
+    }
+    return `${prefix}-${suffix}`;
+}
+export function generateTurnId() {
+    return `turn-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+}
+export function generateSessionId() {
+    return `session-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+}
+//# sourceMappingURL=agentTypes.js.map

package/dist/shared/agentTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentTypes.js","sourceRoot":"","sources":["../../src/shared/agentTypes.ts"],"names":[],"mappings":"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"}

package/dist/shared/codeIndexTypes.d.ts

@@ -0,0 +1,32 @@
+export type CodeSymbolKind = 'class' | 'function' | 'interface' | 'type' | 'enum' | 'constant';
+export type CodeMapNodeKind = 'module' | 'symbol';
+export interface CodeAnchor {
+    path: string;
+    line: number;
+    startLine: number;
+    endLine: number;
+}
+export interface CodeSearchHit extends CodeAnchor {
+    id: string;
+    source: 'symbol' | 'chunk';
+    title: string;
+    subtitle: string;
+    preview: string;
+    score: number;
+    chunkId?: string;
+    symbolId?: string;
+    symbolName?: string;
+    symbolKind?: CodeSymbolKind;
+}
+export interface CodeMapNode {
+    id: string;
+    kind: CodeMapNodeKind;
+    title: string;
+    summary: string;
+    path?: string;
+    line?: number;
+    startLine?: number;
+    endLine?: number;
+    score?: number;
+    children: CodeMapNode[];
+}

package/dist/shared/codeIndexTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=codeIndexTypes.js.map

package/dist/shared/codeIndexTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeIndexTypes.js","sourceRoot":"","sources":["../../src/shared/codeIndexTypes.ts"],"names":[],"mappings":""}

package/dist/shared/flowEvents.d.ts

@@ -0,0 +1,192 @@
+import type { AgentAttachment, AgentMode, AgentRunState, TaskPriority, TokenUsage } from './agentTypes';
+export declare const FLOW_EVENT_SCHEMA_VERSION: 2;
+export type FlowInputIntent = 'turn' | 'steer' | 'queued-turn';
+export type FlowRunOutcome = 'succeeded' | 'failed' | 'interrupted' | 'cancelled';
+export type FlowToolOutcome = 'completed' | 'failed' | 'cancelled';
+export type FlowApprovalKind = 'permission' | 'input';
+export type FlowApprovalDecision = 'allow-once' | 'allow-run' | 'allow-session' | 'deny' | 'answered';
+export interface FlowTaskToolCall {
+    toolCallId: string;
+    toolName: string;
+    status: 'running' | 'completed' | 'error' | 'cancelled';
+    path?: string;
+    result?: string;
+}
+export interface FlowActiveTask {
+    taskId: string;
+    title: string;
+    priority: TaskPriority;
+    progress: number;
+    toolCalls: FlowTaskToolCall[];
+    startedAt: number;
+}
+export type FlowEventPayload = {
+    type: 'thread.activated';
+    previousThreadId?: string;
+} | {
+    type: 'run.started';
+    objective?: string;
+} | {
+    type: 'run.state_changed';
+    state: AgentRunState;
+} | {
+    type: 'run.stopping';
+    reason?: string;
+} | {
+    type: 'run.completed';
+    outcome: FlowRunOutcome;
+    error?: string;
+} | {
+    type: 'session.mode_changed';
+    mode: AgentMode;
+} | {
+    type: 'usage.updated';
+    usage: TokenUsage;
+} | {
+    type: 'task.active_changed';
+    task: FlowActiveTask | null;
+} | {
+    type: 'tool.draft_changed';
+    name: string;
+    partialJson: string;
+} | {
+    type: 'tool.draft_cleared';
+} | {
+    type: 'input.draft_changed';
+    text: string;
+    attachmentIds: string[];
+} | {
+    type: 'input.submitted';
+    intent: FlowInputIntent;
+    text: string;
+    attachmentIds: string[];
+    attachments?: AgentAttachment[];
+} | {
+    type: 'input.durable';
+} | {
+    type: 'input.accepted';
+} | {
+    type: 'input.rejected';
+    reason: string;
+} | {
+    type: 'input.committed';
+} | {
+    type: 'input.restored';
+    reason: string;
+} | {
+    type: 'input.queued';
+    position: number;
+} | {
+    type: 'input.removed';
+    reason: string;
+} | {
+    type: 'approval.requested';
+    kind: FlowApprovalKind;
+    toolName?: string;
+    reason?: string;
+} | {
+    type: 'approval.presented';
+} | {
+    type: 'approval.resolved';
+    decision: FlowApprovalDecision;
+} | {
+    type: 'approval.cancelled';
+    reason: string;
+} | {
+    type: 'tool.proposed';
+    name: string;
+} | {
+    type: 'tool.awaiting_approval';
+    name: string;
+} | {
+    type: 'tool.running';
+    name: string;
+} | {
+    type: 'tool.completed';
+    name: string;
+    outcome: FlowToolOutcome;
+    error?: string;
+} | {
+    type: 'stream.started';
+    channel: 'answer' | 'thinking';
+} | {
+    type: 'stream.delta';
+    channel: 'answer' | 'thinking';
+    text: string;
+} | {
+    type: 'stream.committed';
+    channel: 'answer' | 'thinking';
+    text: string;
+} | {
+    type: 'stream.ended';
+    channel: 'answer' | 'thinking';
+    interrupted: boolean;
+} | {
+    type: 'runtime.started';
+    kind: string;
+    label?: string;
+} | {
+    type: 'runtime.completed';
+    kind: string;
+    outcome: FlowToolOutcome;
+    error?: string;
+} | {
+    type: 'notification.raised';
+    priority: number;
+    category: string;
+    message?: string;
+} | {
+    type: 'notification.acknowledged';
+} | {
+    type: 'journal.flush_started';
+    queued: number;
+} | {
+    type: 'journal.flushed';
+    queued: number;
+    durationMs: number;
+} | {
+    type: 'journal.degraded';
+    error: string;
+};
+export type FlowEventType = FlowEventPayload['type'];
+export type FlowPayloadFor<T extends FlowEventType> = Extract<FlowEventPayload, {
+    type: T;
+}> extends infer Payload ? Payload extends {
+    type: T;
+} ? Omit<Payload, 'type'> : never : never;
+export interface FlowEventEnvelope<T extends FlowEventType = FlowEventType> {
+    schemaVersion: typeof FLOW_EVENT_SCHEMA_VERSION;
+    eventId: string;
+    sessionId: string;
+    threadId: string;
+    runId?: string;
+    turnId?: string;
+    itemId?: string;
+    seq: number;
+    at: number;
+    type: T;
+    payload: FlowPayloadFor<T>;
+}
+export type AnyFlowEvent = {
+    [Type in FlowEventType]: FlowEventEnvelope<Type>;
+}[FlowEventType];
+export interface CreateFlowEventInput<T extends FlowEventType> {
+    sessionId: string;
+    threadId: string;
+    runId?: string;
+    turnId?: string;
+    itemId?: string;
+    type: T;
+    payload: FlowPayloadFor<T>;
+    at?: number;
+    eventId?: string;
+}
+export declare class FlowEventFactory {
+    private readonly now;
+    private readonly createId;
+    private readonly nextSeqByThread;
+    constructor(now?: () => number, createId?: () => string);
+    create<T extends FlowEventType>(input: CreateFlowEventInput<T>): FlowEventEnvelope<T>;
+    observe(event: Pick<AnyFlowEvent, 'threadId' | 'seq'>): void;
+    getLastSequence(threadId: string): number;
+}

package/dist/shared/flowEvents.js

@@ -0,0 +1,37 @@
+import { randomUUID } from 'node:crypto';
+export const FLOW_EVENT_SCHEMA_VERSION = 2;
+export class FlowEventFactory {
+    now;
+    createId;
+    nextSeqByThread = new Map();
+    constructor(now = Date.now, createId = randomUUID) {
+        this.now = now;
+        this.createId = createId;
+    }
+    create(input) {
+        const seq = (this.nextSeqByThread.get(input.threadId) ?? 0) + 1;
+        this.nextSeqByThread.set(input.threadId, seq);
+        return {
+            schemaVersion: FLOW_EVENT_SCHEMA_VERSION,
+            eventId: input.eventId ?? this.createId(),
+            sessionId: input.sessionId,
+            threadId: input.threadId,
+            runId: input.runId,
+            turnId: input.turnId,
+            itemId: input.itemId,
+            seq,
+            at: input.at ?? this.now(),
+            type: input.type,
+            payload: input.payload,
+        };
+    }
+    observe(event) {
+        const current = this.nextSeqByThread.get(event.threadId) ?? 0;
+        if (event.seq > current)
+            this.nextSeqByThread.set(event.threadId, event.seq);
+    }
+    getLastSequence(threadId) {
+        return this.nextSeqByThread.get(threadId) ?? 0;
+    }
+}
+//# sourceMappingURL=flowEvents.js.map

package/dist/shared/flowEvents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowEvents.js","sourceRoot":"","sources":["../../src/shared/flowEvents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAGxC,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAU,CAAA;AAwGnD,MAAM,OAAO,gBAAgB;IAIR;IACA;IAJF,eAAe,GAAG,IAAI,GAAG,EAAkB,CAAA;IAE5D,YACmB,MAAoB,IAAI,CAAC,GAAG,EAC5B,WAAyB,UAAU;QADnC,QAAG,GAAH,GAAG,CAAyB;QAC5B,aAAQ,GAAR,QAAQ,CAA2B;IACnD,CAAC;IAEJ,MAAM,CAA0B,KAA8B;QAC5D,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAA;QAC/D,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAA;QAC7C,OAAO;YACL,aAAa,EAAE,yBAAyB;YACxC,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,IAAI,CAAC,QAAQ,EAAE;YACzC,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,KAAK,EAAE,KAAK,CAAC,KAAK;YAClB,MAAM,EAAE,KAAK,CAAC,MAAM;YACpB,MAAM,EAAE,KAAK,CAAC,MAAM;YACpB,GAAG;YACH,EAAE,EAAE,KAAK,CAAC,EAAE,IAAI,IAAI,CAAC,GAAG,EAAE;YAC1B,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,OAAO,EAAE,KAAK,CAAC,OAAO;SACvB,CAAA;IACH,CAAC;IAED,OAAO,CAAC,KAA6C;QACnD,MAAM,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;QAC7D,IAAI,KAAK,CAAC,GAAG,GAAG,OAAO;YAAE,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG,CAAC,CAAA;IAC9E,CAAC;IAED,eAAe,CAAC,QAAgB;QAC9B,OAAO,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;IAChD,CAAC;CACF"}

package/dist/shared/memoryTypes.d.ts

@@ -0,0 +1,100 @@
+export type MemoryScope = 'global' | 'workspace_shared' | 'workspace_private' | 'conversation';
+export type MemoryKind = 'rule' | 'fact' | 'preference' | 'episode' | 'todo' | 'verdict' | 'strategy' | 'pitfall' | 'workflow';
+export type MemoryConfidence = 'asserted' | 'observed' | 'inferred';
+export interface MemoryEvidence {
+    kind: 'file' | 'tool_result' | 'user_quote' | 'web' | 'conversation';
+    path?: string;
+    lines?: [number, number];
+    quote?: string;
+    conversationId?: string;
+    messageId?: string;
+}
+export interface Memory {
+    id: string;
+    scope: MemoryScope;
+    kind: MemoryKind;
+    text: string;
+    source: string;
+    evidence: MemoryEvidence[];
+    confidence: MemoryConfidence;
+    createdAt: number;
+    updatedAt: number;
+    pinned: boolean;
+    tags: string[];
+    reviewState: 'auto' | 'user_approved' | 'user_edited';
+    status: 'active' | 'superseded' | 'rejected' | 'stale';
+    supersededBy?: string;
+}
+export interface MemoryGroup {
+    id: string;
+    label: string;
+    source: string;
+    loader: string;
+    items: Memory[];
+}
+export interface MemorySnapshot {
+    workspacePath: string;
+    injectionText: string;
+    injectionTokens: number;
+    groups: MemoryGroup[];
+    totalCount: number;
+    warnings: string[];
+    loadersAttempted: string[];
+    builtAt: number;
+}
+export interface MemoryListRequest {
+    workspacePath: string;
+    forceReload?: boolean;
+}
+export interface MemoryListResponse {
+    success: boolean;
+    snapshot?: MemorySnapshot;
+    error?: string;
+}
+export interface MemoryQueryParams {
+    workspacePath: string;
+    scope?: MemoryScope;
+    kind?: MemoryKind;
+    query?: string;
+    limit?: number;
+    includeStale?: boolean;
+}
+export interface MemoryWriteRequest {
+    workspacePath: string;
+    text: string;
+    kind?: MemoryKind;
+    scope?: MemoryScope;
+    tags?: string[];
+    evidence?: MemoryEvidence[];
+    confidence?: MemoryConfidence;
+    conversationId?: string;
+    messageId?: string;
+}
+export interface MemoryWriteResponse {
+    success: boolean;
+    id?: string;
+    error?: string;
+    deduplicated?: boolean;
+}
+export interface MemoryForgetRequest {
+    workspacePath: string;
+    id: string;
+    reason?: string;
+}
+export interface MemoryForgetResponse {
+    success: boolean;
+    error?: string;
+}
+export interface MemoryUpdateRequest {
+    workspacePath: string;
+    id: string;
+    text?: string;
+    kind?: MemoryKind;
+    tags?: string[];
+    pinned?: boolean;
+    status?: Memory['status'];
+}
+export interface MemoryUpdateResponse {
+    success: boolean;
+    error?: string;
+}

package/dist/shared/memoryTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=memoryTypes.js.map

package/dist/shared/memoryTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoryTypes.js","sourceRoot":"","sources":["../../src/shared/memoryTypes.ts"],"names":[],"mappings":""}