squish-memory 1.0.2 → 1.2.0

package/dist/core/places/places.js

@@ -0,0 +1,314 @@
+/**
+ * Places Module - Spatial memory organization
+ *
+ * Provides spatial "places" for memory organization:
+ * - Inbox: New memories, unprocessed
+ * - Ref: Reference, patterns, research
+ * - WIP: Active work, implementations
+ * - Sandbox: Experiments, tests
+ * - Board: Decisions, planning, roadmap
+ * - Sparks: Ideas, future concepts
+ * - Archive: Completed, historical
+ */
+import { randomUUID } from 'crypto';
+import { eq, and, isNull } from 'drizzle-orm';
+import { getDb } from '../../db/index.js';
+import { getSchema } from '../../db/schema.js';
+import { logger } from '../logger.js';
+// Default places configuration
+export const DEFAULT_PLACES = [
+    { name: 'Inbox', placeType: 'inbox', sortOrder: 0, description: 'New memories, unprocessed', purpose: 'Quick inbox for incoming memories' },
+    { name: 'Ref', placeType: 'ref', sortOrder: 1, description: 'Reference, patterns, research', purpose: 'Reference knowledge and learned patterns' },
+    { name: 'WIP', placeType: 'wip', sortOrder: 2, description: 'Active work, implementations', purpose: 'Active development and recent changes' },
+    { name: 'Sandbox', placeType: 'sandbox', sortOrder: 3, description: 'Experiments, tests', purpose: 'Testing and exploration results' },
+    { name: 'Board', placeType: 'board', sortOrder: 4, description: 'Decisions, planning, roadmap', purpose: 'Project direction and decisions' },
+    { name: 'Sparks', placeType: 'sparks', sortOrder: 5, description: 'Ideas, future concepts', purpose: 'Brainstorming and upcoming plans' },
+    { name: 'Archive', placeType: 'archive', sortOrder: 6, description: 'Completed, historical', purpose: 'Reference for completed work' },
+];
+/**
+ * Create a new place
+ */
+export async function createPlace(input) {
+    const db = await getDb();
+    if (!db) {
+        throw new Error('Database unavailable');
+    }
+    const schema = await getSchema();
+    const sqliteDb = db;
+    const id = randomUUID();
+    // Check for duplicate
+    const existing = await sqliteDb.select()
+        .from(schema.places)
+        .where(and(eq(schema.places.projectId, input.projectId), eq(schema.places.name, input.name), input.parentId
+        ? eq(schema.places.parentId, input.parentId)
+        : isNull(schema.places.parentId)))
+        .limit(1);
+    if (existing.length > 0) {
+        throw new Error(`Place "${input.name}" already exists`);
+    }
+    await sqliteDb.insert(schema.places).values({
+        id,
+        projectId: input.projectId,
+        name: input.name,
+        placeType: input.placeType,
+        parentId: input.parentId || null,
+        sortOrder: input.sortOrder ?? 0,
+        positionX: 0,
+        positionY: 0,
+        description: input.description || null,
+        purpose: input.purpose || null,
+        memoryCount: 0,
+    });
+    logger.info(`[Places] Created place: ${input.name} (${input.placeType})`);
+    return {
+        id,
+        projectId: input.projectId,
+        name: input.name,
+        placeType: input.placeType,
+        parentId: input.parentId || null,
+        sortOrder: input.sortOrder ?? 0,
+        positionX: 0,
+        positionY: 0,
+        description: input.description || null,
+        purpose: input.purpose || null,
+        memoryCount: 0,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+    };
+}
+/**
+ * Get a place by ID
+ */
+export async function getPlace(id) {
+    const db = await getDb();
+    if (!db)
+        return null;
+    const schema = await getSchema();
+    const sqliteDb = db;
+    const result = await sqliteDb.select()
+        .from(schema.places)
+        .where(eq(schema.places.id, id))
+        .limit(1);
+    if (result.length === 0)
+        return null;
+    const row = result[0];
+    return {
+        id: row.id,
+        projectId: row.project_id,
+        name: row.name,
+        placeType: (row.place_type || row.placeType || 'custom'),
+        parentId: row.parent_id || row.parentId || null,
+        sortOrder: row.sort_order ?? row.sortOrder ?? 0,
+        positionX: row.position_x ?? row.positionX ?? 0,
+        positionY: row.position_y ?? row.positionY ?? 0,
+        description: row.description,
+        purpose: row.purpose,
+        memoryCount: row.memory_count ?? row.memoryCount ?? 0,
+        createdAt: new Date(row.created_at || row.createdAt || Date.now()),
+        updatedAt: new Date(row.updated_at || row.updatedAt || Date.now()),
+    };
+}
+/**
+ * Get places for a project, ordered by sort_order
+ */
+export async function getProjectPlaces(projectId) {
+    const db = await getDb();
+    if (!db)
+        return [];
+    const schema = await getSchema();
+    const sqliteDb = db;
+    const results = await sqliteDb.select()
+        .from(schema.places)
+        .where(eq(schema.places.projectId, projectId))
+        .orderBy(schema.places.sortOrder);
+    return results.map((row) => ({
+        id: row.id,
+        projectId: row.project_id,
+        name: row.name,
+        placeType: (row.place_type || row.placeType),
+        parentId: row.parent_id || row.parentId,
+        sortOrder: row.sort_order ?? row.sortOrder ?? 0,
+        positionX: row.position_x ?? row.positionX ?? 0,
+        positionY: row.position_y ?? row.positionY ?? 0,
+        description: row.description,
+        purpose: row.purpose,
+        memoryCount: row.memory_count ?? row.memoryCount ?? 0,
+        createdAt: new Date(row.created_at || row.createdAt),
+        updatedAt: new Date(row.updated_at || row.updatedAt),
+    }));
+}
+/**
+ * Get place by type for a project
+ */
+export async function getPlaceByType(projectId, placeType) {
+    const db = await getDb();
+    if (!db)
+        return null;
+    const schema = await getSchema();
+    const sqliteDb = db;
+    const result = await sqliteDb.select()
+        .from(schema.places)
+        .where(and(eq(schema.places.projectId, projectId), eq(schema.places.placeType, placeType)))
+        .limit(1);
+    if (result.length === 0)
+        return null;
+    const row = result[0];
+    return {
+        id: row.id,
+        projectId: row.project_id,
+        name: row.name,
+        placeType: (row.place_type || row.placeType || 'custom'),
+        parentId: row.parent_id || row.parentId || null,
+        sortOrder: row.sort_order ?? row.sortOrder ?? 0,
+        positionX: row.position_x ?? row.positionX ?? 0,
+        positionY: row.position_y ?? row.positionY ?? 0,
+        description: row.description,
+        purpose: row.purpose,
+        memoryCount: row.memory_count ?? row.memoryCount ?? 0,
+        createdAt: new Date(row.created_at || row.createdAt || Date.now()),
+        updatedAt: new Date(row.updated_at || row.updatedAt || Date.now()),
+    };
+}
+/**
+ * Update a place
+ */
+export async function updatePlace(id, input) {
+    const db = await getDb();
+    if (!db)
+        return null;
+    const schema = await getSchema();
+    const sqliteDb = db;
+    const updateData = {};
+    if (input.name !== undefined)
+        updateData.name = input.name;
+    if (input.description !== undefined)
+        updateData.description = input.description;
+    if (input.purpose !== undefined)
+        updateData.purpose = input.purpose;
+    if (input.sortOrder !== undefined)
+        updateData.sortOrder = input.sortOrder;
+    if (input.positionX !== undefined)
+        updateData.positionX = input.positionX;
+    if (input.positionY !== undefined)
+        updateData.positionY = input.positionY;
+    if (Object.keys(updateData).length === 0) {
+        return getPlace(id);
+    }
+    await sqliteDb.update(schema.places)
+        .set(updateData)
+        .where(eq(schema.places.id, id));
+    return getPlace(id);
+}
+/**
+ * Delete a place
+ */
+export async function deletePlace(id) {
+    const db = await getDb();
+    if (!db)
+        return false;
+    const schema = await getSchema();
+    const sqliteDb = db;
+    await sqliteDb.delete(schema.places).where(eq(schema.places.id, id));
+    logger.info(`[Places] Deleted place: ${id}`);
+    return true;
+}
+/**
+ * Initialize default 7 places for a project
+ */
+export async function initializeDefaultPlaces(projectId) {
+    const created = [];
+    for (const placeConfig of DEFAULT_PLACES) {
+        // Check if place of this type already exists
+        const existing = await getPlaceByType(projectId, placeConfig.placeType);
+        if (existing) {
+            created.push(existing);
+            continue;
+        }
+        const place = await createPlace({
+            projectId,
+            name: placeConfig.name,
+            placeType: placeConfig.placeType,
+            parentId: null,
+            sortOrder: placeConfig.sortOrder,
+            description: placeConfig.description,
+            purpose: placeConfig.purpose,
+        });
+        created.push(place);
+    }
+    // Also initialize default rules if none exist
+    const { initializeDefaultRules } = await import('./rules.js');
+    await initializeDefaultRules(projectId);
+    logger.info(`[Places] Initialized ${created.length} default places for project: ${projectId}`);
+    return created;
+}
+/**
+ * Get place by loci index
+ */
+export async function getPlaceByLociIndex(projectId, sortOrder) {
+    const db = await getDb();
+    if (!db)
+        return null;
+    const schema = await getSchema();
+    const sqliteDb = db;
+    const result = await sqliteDb.select()
+        .from(schema.places)
+        .where(and(eq(schema.places.projectId, projectId), eq(schema.places.sortOrder, sortOrder)))
+        .limit(1);
+    if (result.length === 0)
+        return null;
+    const row = result[0];
+    return {
+        id: row.id,
+        projectId: row.project_id,
+        name: row.name,
+        placeType: (row.place_type || row.placeType || 'custom'),
+        parentId: row.parent_id || row.parentId || null,
+        sortOrder: row.sort_order ?? row.sortOrder ?? 0,
+        positionX: row.position_x ?? row.positionX ?? 0,
+        positionY: row.position_y ?? row.positionY ?? 0,
+        description: row.description,
+        purpose: row.purpose,
+        memoryCount: row.memory_count ?? row.memoryCount ?? 0,
+        createdAt: new Date(row.created_at || row.createdAt || Date.now()),
+        updatedAt: new Date(row.updated_at || row.updatedAt || Date.now()),
+    };
+}
+/**
+ * Update memory count for a place
+ */
+export async function updatePlaceMemoryCount(placeId) {
+    const db = await getDb();
+    if (!db)
+        return;
+    const schema = await getSchema();
+    const sqliteDb = db;
+    // Count memories in this place
+    const countResult = await sqliteDb.select({ count: schema.memoryPlaces.id })
+        .from(schema.memoryPlaces)
+        .where(eq(schema.memoryPlaces.placeId, placeId));
+    const count = countResult.length;
+    await sqliteDb.update(schema.places)
+        .set({ memoryCount: count })
+        .where(eq(schema.places.id, placeId));
+}
+/**
+ * Sync all place memory counts - recalculate counts for all places in a project
+ * Useful for fixing counts after bulk operations or data recovery
+ */
+export async function syncAllPlaceMemoryCounts(projectId) {
+    const db = await getDb();
+    if (!db)
+        return;
+    const schema = await getSchema();
+    const sqliteDb = db;
+    // Get all places for this project
+    const allPlaces = await sqliteDb.select()
+        .from(schema.places)
+        .where(eq(schema.places.projectId, projectId));
+    // Update each place's memory count
+    for (const place of allPlaces) {
+        await updatePlaceMemoryCount(place.id);
+    }
+    logger.info(`[Places] Synced memory counts for ${allPlaces.length} places`);
+}
+//# sourceMappingURL=places.js.map

package/dist/core/places/rules.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Places Rules Engine - Auto-assignment logic
+ *
+ * Evaluates which place a memory should be assigned to based on:
+ * - Tool used (Write, Edit, Task, etc.)
+ * - Content keywords
+ * - Tags
+ * - Memory type
+ */
+import type { PlaceType } from './places.js';
+export interface PlaceRule {
+    id: string;
+    projectId: string;
+    name: string;
+    placeType: PlaceType;
+    matchTool: string | null;
+    matchKeyword: string | null;
+    matchTag: string | null;
+    matchMemoryType: string | null;
+    priority: number;
+    enabled: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface PlaceRuleCreateInput {
+    projectId: string;
+    name: string;
+    placeType: PlaceType;
+    matchTool?: string;
+    matchKeyword?: string;
+    matchTag?: string;
+    matchMemoryType?: string;
+    priority?: number;
+    enabled?: boolean;
+}
+export interface RuleMatchInput {
+    toolName?: string;
+    content?: string;
+    tags?: string[];
+    memoryType?: string;
+}
+/**
+ * Default auto-assignment rules
+ */
+export declare const DEFAULT_RULES: Omit<PlaceRuleCreateInput, 'projectId'>[];
+/**
+ * Create a place rule
+ */
+export declare function createPlaceRule(input: PlaceRuleCreateInput): Promise<PlaceRule>;
+/**
+ * Get rules for a project
+ */
+export declare function getProjectRules(projectId: string): Promise<PlaceRule[]>;
+/**
+ * Check if a rule matches the input
+ */
+export declare function matchesRule(rule: PlaceRule, input: RuleMatchInput): boolean;
+/**
+ * Find matching place for a memory based on rules
+ */
+export declare function findMatchingPlace(projectId: string, input: RuleMatchInput): Promise<PlaceType | null>;
+/**
+ * Initialize default rules for a project
+ */
+export declare function initializeDefaultRules(projectId: string): Promise<PlaceRule[]>;
+/**
+ * Delete a rule
+ */
+export declare function deletePlaceRule(id: string): Promise<boolean>;
+/**
+ * Update a rule
+ */
+export declare function updatePlaceRule(id: string, updates: Partial<PlaceRuleCreateInput>): Promise<PlaceRule | null>;
+//# sourceMappingURL=rules.d.ts.map

package/dist/core/places/rules.js

@@ -0,0 +1,240 @@
+/**
+ * Places Rules Engine - Auto-assignment logic
+ *
+ * Evaluates which place a memory should be assigned to based on:
+ * - Tool used (Write, Edit, Task, etc.)
+ * - Content keywords
+ * - Tags
+ * - Memory type
+ */
+import { randomUUID } from 'crypto';
+import { eq, desc } from 'drizzle-orm';
+import { getDb } from '../../db/index.js';
+import { getSchema } from '../../db/schema.js';
+import { logger } from '../logger.js';
+/**
+ * Default auto-assignment rules
+ */
+export const DEFAULT_RULES = [
+    // WIP - Implementation, code, fixes
+    { name: 'Write to WIP', placeType: 'wip', matchTool: 'Write', priority: 100 },
+    { name: 'Edit to WIP', placeType: 'wip', matchTool: 'Edit', priority: 100 },
+    { name: 'MultiEdit to WIP', placeType: 'wip', matchTool: 'MultiEdit', priority: 100 },
+    { name: 'Fix keyword to WIP', placeType: 'wip', matchKeyword: 'fix', priority: 80 },
+    { name: 'Bug keyword to WIP', placeType: 'wip', matchKeyword: 'bug', priority: 80 },
+    // Sandbox - Experiments, tests
+    { name: 'Test to Sandbox', placeType: 'sandbox', matchTool: 'Bash', matchKeyword: 'test', priority: 90 },
+    { name: 'Test tag to Sandbox', placeType: 'sandbox', matchTag: 'test', priority: 85 },
+    // Board - Decisions, planning
+    { name: 'Task to Board', placeType: 'board', matchTool: 'Task', priority: 100 },
+    { name: 'TodoWrite to Board', placeType: 'board', matchTool: 'TodoWrite', priority: 100 },
+    { name: 'Decision keyword to Board', placeType: 'board', matchKeyword: 'decided', priority: 70 },
+    { name: 'Planning keyword to Board', placeType: 'board', matchKeyword: 'will implement', priority: 70 },
+    // Ref - Research, patterns
+    { name: 'Search to Ref', placeType: 'ref', matchTool: 'grep', priority: 90 },
+    { name: 'WebFetch to Ref', placeType: 'ref', matchTool: 'WebFetch', priority: 85 },
+    { name: 'Research keyword to Ref', placeType: 'ref', matchKeyword: 'research', priority: 80 },
+    { name: 'Pattern keyword to Ref', placeType: 'ref', matchKeyword: 'pattern', priority: 75 },
+    // Sparks - Ideas, future
+    { name: 'Idea keyword to Sparks', placeType: 'sparks', matchKeyword: 'idea', priority: 80 },
+    { name: 'Explore keyword to Sparks', placeType: 'sparks', matchKeyword: 'explore', priority: 75 },
+    { name: 'Future keyword to Sparks', placeType: 'sparks', matchKeyword: 'will add', priority: 70 },
+];
+/**
+ * Create a place rule
+ */
+export async function createPlaceRule(input) {
+    const db = await getDb();
+    if (!db) {
+        throw new Error('Database unavailable');
+    }
+    const schema = await getSchema();
+    const sqliteDb = db;
+    const id = randomUUID();
+    await sqliteDb.insert(schema.placeRules).values({
+        id,
+        projectId: input.projectId,
+        name: input.name,
+        placeType: input.placeType,
+        matchTool: input.matchTool || null,
+        matchKeyword: input.matchKeyword || null,
+        matchTag: input.matchTag || null,
+        matchMemoryType: input.matchMemoryType || null,
+        priority: input.priority ?? 0,
+        enabled: input.enabled !== false ? 1 : 0,
+    });
+    logger.info(`[PlaceRules] Created rule: ${input.name} -> ${input.placeType}`);
+    return {
+        id,
+        projectId: input.projectId,
+        name: input.name,
+        placeType: input.placeType,
+        matchTool: input.matchTool || null,
+        matchKeyword: input.matchKeyword || null,
+        matchTag: input.matchTag || null,
+        matchMemoryType: input.matchMemoryType || null,
+        priority: input.priority ?? 0,
+        enabled: input.enabled ?? true,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+    };
+}
+/**
+ * Get rules for a project
+ */
+export async function getProjectRules(projectId) {
+    const db = await getDb();
+    if (!db)
+        return [];
+    const schema = await getSchema();
+    const sqliteDb = db;
+    const results = await sqliteDb.select()
+        .from(schema.placeRules)
+        .where(eq(schema.placeRules.projectId, projectId))
+        .orderBy(desc(schema.placeRules.priority));
+    return results.map((row) => ({
+        id: row.id,
+        projectId: row.project_id,
+        name: row.name,
+        placeType: (row.place_type || row.placeType || 'custom'),
+        matchTool: row.match_tool || row.matchTool,
+        matchKeyword: row.match_keyword || row.matchKeyword,
+        matchTag: row.match_tag || row.matchTag,
+        matchMemoryType: row.match_memory_type || row.matchMemoryType,
+        priority: row.priority ?? 0,
+        enabled: row.enabled === 1 || row.enabled === true,
+        createdAt: new Date(row.created_at || Date.now()),
+        updatedAt: new Date(row.updated_at || Date.now()),
+    }));
+}
+/**
+ * Check if a rule matches the input
+ */
+export function matchesRule(rule, input) {
+    // Check tool match
+    if (rule.matchTool && input.toolName) {
+        if (input.toolName.toLowerCase() !== rule.matchTool.toLowerCase()) {
+            return false;
+        }
+    }
+    // Check keyword match
+    if (rule.matchKeyword && input.content) {
+        const contentLower = input.content.toLowerCase();
+        if (!contentLower.includes(rule.matchKeyword.toLowerCase())) {
+            return false;
+        }
+    }
+    // Check tag match
+    if (rule.matchTag && input.tags) {
+        const hasTag = input.tags.some(t => t.toLowerCase() === rule.matchTag.toLowerCase());
+        if (!hasTag) {
+            return false;
+        }
+    }
+    // Check memory type match
+    if (rule.matchMemoryType && input.memoryType) {
+        if (input.memoryType.toLowerCase() !== rule.matchMemoryType.toLowerCase()) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Find matching place for a memory based on rules
+ */
+export async function findMatchingPlace(projectId, input) {
+    const rules = await getProjectRules(projectId);
+    // Sort by priority (highest first)
+    const sortedRules = rules
+        .filter(r => r.enabled)
+        .sort((a, b) => b.priority - a.priority);
+    for (const rule of sortedRules) {
+        if (matchesRule(rule, input)) {
+            logger.info(`[PlaceRules] Matched rule "${rule.name}" -> ${rule.placeType}`);
+            return rule.placeType;
+        }
+    }
+    return null;
+}
+/**
+ * Initialize default rules for a project
+ */
+export async function initializeDefaultRules(projectId) {
+    const created = [];
+    for (const ruleConfig of DEFAULT_RULES) {
+        const rule = await createPlaceRule({
+            projectId,
+            ...ruleConfig,
+        });
+        created.push(rule);
+    }
+    logger.info(`[PlaceRules] Initialized ${created.length} default rules for project: ${projectId}`);
+    return created;
+}
+/**
+ * Delete a rule
+ */
+export async function deletePlaceRule(id) {
+    const db = await getDb();
+    if (!db)
+        return false;
+    const schema = await getSchema();
+    const sqliteDb = db;
+    await sqliteDb.delete(schema.placeRules).where(eq(schema.placeRules.id, id));
+    logger.info(`[PlaceRules] Deleted rule: ${id}`);
+    return true;
+}
+/**
+ * Update a rule
+ */
+export async function updatePlaceRule(id, updates) {
+    const db = await getDb();
+    if (!db)
+        return null;
+    const schema = await getSchema();
+    const sqliteDb = db;
+    const updateData = {};
+    if (updates.name !== undefined)
+        updateData.name = updates.name;
+    if (updates.placeType !== undefined)
+        updateData.placeType = updates.placeType;
+    if (updates.matchTool !== undefined)
+        updateData.matchTool = updates.matchTool;
+    if (updates.matchKeyword !== undefined)
+        updateData.matchKeyword = updates.matchKeyword;
+    if (updates.matchTag !== undefined)
+        updateData.matchTag = updates.matchTag;
+    if (updates.matchMemoryType !== undefined)
+        updateData.matchMemoryType = updates.matchMemoryType;
+    if (updates.priority !== undefined)
+        updateData.priority = updates.priority;
+    if (updates.enabled !== undefined)
+        updateData.enabled = updates.enabled;
+    if (Object.keys(updateData).length === 0)
+        return null;
+    await sqliteDb.update(schema.placeRules)
+        .set(updateData)
+        .where(eq(schema.placeRules.id, id));
+    const result = await sqliteDb.select()
+        .from(schema.placeRules)
+        .where(eq(schema.placeRules.id, id))
+        .limit(1);
+    if (result.length === 0)
+        return null;
+    const row = result[0];
+    return {
+        id: row.id,
+        projectId: row.project_id,
+        name: row.name,
+        placeType: row.place_type,
+        matchTool: row.match_tool,
+        matchKeyword: row.match_keyword,
+        matchTag: row.match_tag,
+        matchMemoryType: row.match_memory_type,
+        priority: row.priority,
+        enabled: row.enabled === 1 || row.enabled === true,
+        createdAt: new Date(row.created_at),
+        updatedAt: new Date(row.updated_at),
+    };
+}
+//# sourceMappingURL=rules.js.map

package/dist/core/places/walking.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Walking Interface - Sequential memory retrieval through places
+ *
+ * Implements place walking through memory places:
+ * - Walk single place to get memories in order
+ * - Walk all places for full tour
+ * - Token budget handling with TOON compression
+ */
+import { type Place } from './places.js';
+export interface WalkOptions {
+    tokenBudget?: number;
+    maxMemoriesPerPlace?: number;
+    includePurpose?: boolean;
+    compressWithCompression?: boolean;
+}
+export interface WalkResult {
+    place: Place;
+    memories: MemorySummary[];
+    totalTokens: number;
+    truncated: boolean;
+}
+export interface MemorySummary {
+    id: string;
+    content: string;
+    type: string;
+    tags: string[];
+    createdAt: string;
+}
+/**
+ * Walk through a single place
+ */
+export declare function walkPlace(projectId: string, placeType: string, options?: WalkOptions): Promise<WalkResult | null>;
+/**
+  * Walk through all places in sort order
+ */
+export declare function walkAllPlaces(projectId: string, options?: WalkOptions): Promise<WalkResult[]>;
+/**
+ * Quick tour - just place names and purposes (minimal tokens)
+ */
+export declare function quickTour(projectId: string): Promise<{
+    places: {
+        name: string;
+        purpose: string;
+        memoryCount: number;
+    }[];
+    totalMemories: number;
+}>;
+/**
+ * Get context summary for a place (for injection)
+ */
+export declare function getPlaceContext(projectId: string, placeType: string, maxTokens?: number): Promise<string>;
+/**
+ * Full context for session start (all places)
+ */
+export declare function getFullWalkingContext(projectId: string, maxTokens?: number): Promise<string>;
+//# sourceMappingURL=walking.d.ts.map