chapterhouse 0.13.1 → 0.14.1

package/dist/copilot/tools/memory.js

@@ -1,678 +0,0 @@
-import { defineTool } from "@github/copilot-sdk";
-import { z } from "zod";
-import { getDb } from "../../store/db.js";
-import { appendTimeline } from "../../wiki/timeline.js";
-import { topicPagePath } from "../../wiki/topic-structure.js";
-import { childLogger } from "../../util/logger.js";
-import { getAgent, loadAgents, agentsModule } from "../tools-deps.js";
-import { getCurrentSessionKey, invalidateOrchestratorSession, maybeScheduleScopeChangeCheckpoint, resetCheckpointSessionState, } from "../tools-deps.js";
-import { getActiveScope as getMemoryActiveScope, createScope as createMemoryScope, getScope as getMemoryScope, inferScopeFromText, completeActionItem, demoteToCold, demoteToWarm, dropActionItem, queueMemoryProposal, recall as recallMemory, listActionItems, recordDecision, recordActionItem, recordObservation, runHousekeeping, reflectOnScope, reflectAllScopes, setActiveScope as setMemoryActiveScope, snoozeActionItem, promoteToHot, upsertEntity, hookDispatcher, } from "../../memory/index.js";
-const log = childLogger("tools");
-function requireOrchestratorMemoryWrite() {
-    const agentSlug = agentsModule.getCurrentToolAgentSlug?.();
-    if (agentSlug && agentSlug !== "chapterhouse") {
-        return "Memory writes are orchestrator-only. Use memory_propose instead.";
-    }
-    return null;
-}
-function resolveProposalScopeSlug(requestedScopeSlug) {
-    if (requestedScopeSlug) {
-        return requestedScopeSlug;
-    }
-    const agentSlug = agentsModule.getCurrentToolAgentSlug?.();
-    if (!agentSlug || agentSlug === "chapterhouse") {
-        return getMemoryActiveScope()?.slug;
-    }
-    const agent = getAgent(agentSlug);
-    const boundScope = agent?.scope ?? loadAgents().find((entry) => entry.slug === agentSlug)?.scope;
-    if (boundScope && getMemoryScope(boundScope)) {
-        return boundScope;
-    }
-    return getMemoryActiveScope()?.slug;
-}
-function resolveMemoryScopeForWrite(explicitScope, content) {
-    const explicit = explicitScope ? getMemoryScope(explicitScope) : undefined;
-    if (explicitScope && !explicit) {
-        throw new Error(`Unknown memory scope '${explicitScope}'.`);
-    }
-    if (explicit) {
-        return { scopeId: explicit.id, scopeSlug: explicit.slug };
-    }
-    const active = getMemoryActiveScope();
-    if (active) {
-        return { scopeId: active.id, scopeSlug: active.slug };
-    }
-    const inferred = inferScopeFromText(content);
-    if (inferred) {
-        const inferredScope = getMemoryScope(inferred.scope_id);
-        if (inferredScope) {
-            return { scopeId: inferredScope.id, scopeSlug: inferredScope.slug };
-        }
-    }
-    const validScopes = getDb().prepare(`
-    SELECT slug
-    FROM mem_scopes
-    WHERE active = 1
-    ORDER BY slug
-  `).all();
-    const activeScope = getMemoryActiveScope()?.slug ?? "none";
-    throw new Error(`No scope inferred. Active scope: ${activeScope}. Valid scopes: [${validScopes.map((row) => row.slug).join(", ")}]. `
-        + "Set active scope with memory_set_scope or pass scope explicitly.");
-}
-const observationProposalPayloadSchema = z.object({
-    content: z.string(),
-    entity_id: z.number().int().positive().optional(),
-    source: z.string().optional(),
-});
-const decisionProposalPayloadSchema = z.object({
-    title: z.string(),
-    rationale: z.string().optional(),
-    decided_at: z.string().optional(),
-});
-const entityProposalPayloadSchema = z.object({
-    name: z.string(),
-    entity_kind: z.string().optional(),
-    kind: z.string().optional(),
-    summary: z.string().optional(),
-}).superRefine((value, context) => {
-    if (!value.entity_kind && !value.kind) {
-        context.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "entity_kind is required for entity proposals.",
-            path: ["entity_kind"],
-        });
-    }
-}).transform((value) => ({
-    name: value.name,
-    entity_kind: value.entity_kind ?? value.kind,
-    summary: value.summary,
-}));
-const actionItemProposalPayloadSchema = z.object({
-    title: z.string().trim().min(1, "title is required for action_item proposals."),
-    detail: z.string().optional(),
-    due_at: z.string().optional(),
-    source: z.string().optional(),
-    entity_id: z.number().int().positive().optional(),
-    entity_name: z.string().trim().min(1, "entity_name must be non-empty when provided.").optional(),
-    entity_kind: z.string().trim().min(1, "entity_kind must be non-empty when provided.").optional(),
-}).superRefine((value, context) => {
-    if ((value.entity_name && !value.entity_kind) || (!value.entity_name && value.entity_kind)) {
-        context.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "entity_name and entity_kind must be provided together for action_item proposals.",
-            path: ["entity_name"],
-        });
-    }
-    if (value.entity_id !== undefined && value.entity_name) {
-        context.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "Provide either entity_id or entity_name/entity_kind for action_item proposals, not both.",
-            path: ["entity_id"],
-        });
-    }
-});
-const memoryProposeArgsSchema = z.object({
-    kind: z.enum(["observation", "decision", "entity", "action_item"]),
-    scope_slug: z.string().optional(),
-    payload: z.record(z.string(), z.unknown()),
-    confidence: z.number().min(0).max(1).optional(),
-    reason: z.string().optional(),
-}).superRefine((value, context) => {
-    const schema = value.kind === "observation"
-        ? observationProposalPayloadSchema
-        : value.kind === "decision"
-            ? decisionProposalPayloadSchema
-            : value.kind === "entity"
-                ? entityProposalPayloadSchema
-                : actionItemProposalPayloadSchema;
-    const parsed = schema.safeParse(value.payload);
-    if (!parsed.success) {
-        for (const issue of parsed.error.issues) {
-            context.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: issue.message,
-                path: ["payload", ...issue.path],
-            });
-        }
-    }
-});
-const memoryTierTableSchema = z.enum(["observation", "decision", "entity", "action_item"]);
-export function createMemoryTools(_deps) {
-    return [
-        defineTool("memory_remember", {
-            description: "Write scoped agent memory (observation or decision) into the SQLite memory store. " +
-                "Use this for the new agent-memory system, not the legacy wiki-backed remember tool.",
-            parameters: z.object({
-                content: z.string().describe("Observation content or decision rationale."),
-                scope: z.string().optional().describe("Optional memory scope slug. Defaults to active scope, then keyword inference."),
-                kind: z.enum(["observation", "decision"]).optional().describe("Memory entry kind. Defaults to observation."),
-                entity_name: z.string().optional().describe("Optional entity name to attach. Auto-upserts the entity if provided."),
-                entity_kind: z.string().optional().describe("Required when entity_name is provided."),
-                title: z.string().optional().describe("Required for decision entries."),
-                decided_at: z.string().optional().describe("Decision date. Defaults to today."),
-                tier: z.enum(["hot", "warm", "cold"]).optional().describe("Storage tier. Defaults to warm."),
-            }),
-            handler: async (args) => {
-                const denied = requireOrchestratorMemoryWrite();
-                if (denied)
-                    return denied;
-                if (args.entity_name && !args.entity_kind) {
-                    return "entity_kind is required when entity_name is provided.";
-                }
-                try {
-                    const { scopeId, scopeSlug } = resolveMemoryScopeForWrite(args.scope, args.content);
-                    const kind = args.kind ?? "observation";
-                    const entity = args.entity_name
-                        ? upsertEntity({
-                            scope_id: scopeId,
-                            kind: args.entity_kind,
-                            name: args.entity_name,
-                            tier: args.tier ?? "warm",
-                        })
-                        : undefined;
-                    if (kind === "decision") {
-                        if (!args.title) {
-                            return "title is required when kind='decision'.";
-                        }
-                        const decision = recordDecision({
-                            scope_id: scopeId,
-                            entity_id: entity?.id,
-                            title: args.title,
-                            rationale: args.content,
-                            decided_at: args.decided_at ?? new Date().toISOString().slice(0, 10),
-                            tier: args.tier ?? "warm",
-                        });
-                        if (entity) {
-                            appendTimeline(topicPagePath(entity.kind, entity.name), `${decision.title}\n\n${decision.rationale}`);
-                        }
-                        hookDispatcher.dispatch("memory:decision", {
-                            id: decision.id,
-                            scope_id: scopeId,
-                            title: decision.title,
-                            rationale: decision.rationale,
-                        }).catch((err) => {
-                            log.error({ err }, "memory.hooks.decision.dispatch_error");
-                        });
-                        return {
-                            ok: true,
-                            id: decision.id,
-                            scope: scopeSlug,
-                            kind,
-                            entity_id: entity?.id,
-                        };
-                    }
-                    const observation = recordObservation({
-                        scope_id: scopeId,
-                        entity_id: entity?.id,
-                        content: args.content,
-                        source: `agent:${agentsModule.getCurrentToolAgentSlug?.() ?? "chapterhouse"}`,
-                        tier: args.tier ?? "warm",
-                    });
-                    return {
-                        ok: true,
-                        id: observation.id,
-                        scope: scopeSlug,
-                        kind,
-                        entity_id: entity?.id,
-                    };
-                }
-                catch (err) {
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-        defineTool("memory_propose", {
-            description: "Queue a proposed scoped memory item for orchestrator review at end-of-task. " +
-                "Available to all agents; writes land in mem_inbox as pending proposals.",
-            parameters: memoryProposeArgsSchema,
-            handler: async (args) => {
-                try {
-                    const parsedArgs = memoryProposeArgsSchema.parse(args);
-                    const payload = parsedArgs.kind === "observation"
-                        ? observationProposalPayloadSchema.parse(parsedArgs.payload)
-                        : parsedArgs.kind === "decision"
-                            ? decisionProposalPayloadSchema.parse(parsedArgs.payload)
-                            : parsedArgs.kind === "entity"
-                                ? entityProposalPayloadSchema.parse(parsedArgs.payload)
-                                : actionItemProposalPayloadSchema.parse(parsedArgs.payload);
-                    const proposal = queueMemoryProposal({
-                        kind: parsedArgs.kind,
-                        scopeSlug: resolveProposalScopeSlug(parsedArgs.scope_slug),
-                        payload,
-                        confidence: parsedArgs.confidence ?? 0.5,
-                        reason: parsedArgs.reason,
-                        sourceAgent: agentsModule.getCurrentToolAgentSlug?.() ?? "chapterhouse",
-                        sourceTaskId: agentsModule.getCurrentToolTaskId?.(),
-                    });
-                    return {
-                        proposal_id: proposal.id,
-                        status: "queued",
-                    };
-                }
-                catch (err) {
-                    if (err instanceof z.ZodError) {
-                        return err.issues.map((issue) => issue.message).join("; ");
-                    }
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-        defineTool("memory_create_scope", {
-            description: "Create a new user-defined memory scope. Slugs must be unique kebab-case; baseline installs only include global and chapterhouse.",
-            parameters: z.object({
-                slug: z.string()
-                    .trim()
-                    .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "slug must be unique kebab-case"),
-                title: z.string().trim().min(1, "title is required"),
-                description: z.string().optional(),
-            }),
-            handler: async (args) => {
-                const denied = requireOrchestratorMemoryWrite();
-                if (denied)
-                    return denied;
-                const parsed = z.object({
-                    slug: z.string()
-                        .trim()
-                        .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "slug must be unique kebab-case"),
-                    title: z.string().trim().min(1, "title is required"),
-                    description: z.string().optional(),
-                }).safeParse(args);
-                if (!parsed.success) {
-                    return parsed.error.issues.map((issue) => issue.message).join("; ");
-                }
-                try {
-                    if (getMemoryScope(parsed.data.slug)) {
-                        return `Memory scope '${parsed.data.slug}' already exists.`;
-                    }
-                    const scope = createMemoryScope({
-                        slug: parsed.data.slug,
-                        title: parsed.data.title,
-                        description: parsed.data.description ?? "",
-                        keywords: [parsed.data.slug],
-                    });
-                    hookDispatcher.dispatch("scope:created", {
-                        slug: scope.slug,
-                        title: scope.title,
-                        description: scope.description,
-                    }).catch((err) => {
-                        log.error({ err }, "memory.hooks.scope_created.dispatch_error");
-                    });
-                    return {
-                        ok: true,
-                        scope: {
-                            slug: scope.slug,
-                            title: scope.title,
-                            description: scope.description,
-                            active: scope.active,
-                        },
-                    };
-                }
-                catch (err) {
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-        defineTool("memory_add_action_item", {
-            description: "Add a scoped memory action item/reminder. Orchestrator-only write tool for follow-ups and proactive reminders.",
-            parameters: z.object({
-                scope: z.string().optional().describe("Optional memory scope slug. Defaults to active scope, then keyword inference."),
-                title: z.string().min(1).describe("Short action item title."),
-                detail: z.string().optional().describe("Longer action item detail."),
-                due_at: z.string().optional().describe("Optional ISO due timestamp."),
-                entity_name: z.string().optional().describe("Optional entity name to attach. Auto-upserts the entity if provided."),
-                entity_kind: z.string().optional().describe("Required when entity_name is provided."),
-                source: z.string().optional().describe("Action item source, e.g. manual, subagent_proposal, external."),
-            }),
-            handler: async (args) => {
-                const denied = requireOrchestratorMemoryWrite();
-                if (denied)
-                    return denied;
-                if (args.entity_name && !args.entity_kind) {
-                    return "entity_kind is required when entity_name is provided.";
-                }
-                try {
-                    const { scopeId, scopeSlug } = resolveMemoryScopeForWrite(args.scope, `${args.title}\n${args.detail ?? ""}`);
-                    const entity = args.entity_name
-                        ? upsertEntity({
-                            scope_id: scopeId,
-                            kind: args.entity_kind,
-                            name: args.entity_name,
-                        })
-                        : undefined;
-                    const actionItem = recordActionItem({
-                        scope_id: scopeId,
-                        entity_id: entity?.id,
-                        title: args.title,
-                        detail: args.detail,
-                        due_at: args.due_at,
-                        source: args.source ?? "manual",
-                    });
-                    return {
-                        ok: true,
-                        id: actionItem.id,
-                        scope: scopeSlug,
-                        status: actionItem.status,
-                        entity_id: entity?.id,
-                    };
-                }
-                catch (err) {
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-        defineTool("memory_complete_action_item", {
-            description: "Complete a memory action item. Orchestrator-only write tool.",
-            parameters: z.object({
-                id: z.number().int().positive(),
-                resolution_reason: z.string().optional(),
-            }),
-            handler: async (args) => {
-                const denied = requireOrchestratorMemoryWrite();
-                if (denied)
-                    return denied;
-                try {
-                    const actionItem = completeActionItem(args.id, args.resolution_reason);
-                    return { ok: true, id: actionItem.id, status: actionItem.status, resolved_at: actionItem.resolvedAt };
-                }
-                catch (err) {
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-        defineTool("memory_drop_action_item", {
-            description: "Drop a memory action item with a reason. Orchestrator-only write tool.",
-            parameters: z.object({
-                id: z.number().int().positive(),
-                reason: z.string().min(1),
-            }),
-            handler: async (args) => {
-                const denied = requireOrchestratorMemoryWrite();
-                if (denied)
-                    return denied;
-                try {
-                    const actionItem = dropActionItem(args.id, args.reason);
-                    return { ok: true, id: actionItem.id, status: actionItem.status, resolved_at: actionItem.resolvedAt };
-                }
-                catch (err) {
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-        defineTool("memory_snooze_action_item", {
-            description: "Snooze a memory action item until an ISO timestamp. Orchestrator-only write tool.",
-            parameters: z.object({
-                id: z.number().int().positive(),
-                snooze_until: z.string().min(1),
-            }),
-            handler: async (args) => {
-                const denied = requireOrchestratorMemoryWrite();
-                if (denied)
-                    return denied;
-                try {
-                    const actionItem = snoozeActionItem(args.id, args.snooze_until);
-                    return {
-                        ok: true,
-                        id: actionItem.id,
-                        status: actionItem.status,
-                        snooze_until: actionItem.snoozeUntil,
-                    };
-                }
-                catch (err) {
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-        defineTool("memory_list_action_items", {
-            description: "List scoped memory action items/reminders. Defaults to currently actionable open items.",
-            parameters: z.object({
-                scope: z.string().optional().describe("Optional memory scope slug. Defaults to active scope when available."),
-                status: z.enum(["open", "done", "dropped", "snoozed"]).optional().describe("Optional status filter."),
-                due_before: z.string().optional().describe("Optional ISO timestamp; only include items due at or before this time."),
-                includeArchived: z.boolean().optional().describe("Include cold-tier items. Defaults to false."),
-            }),
-            handler: async (args) => {
-                const requestedScope = args.scope ? getMemoryScope(args.scope) : undefined;
-                if (args.scope && !requestedScope) {
-                    return `Unknown memory scope '${args.scope}'.`;
-                }
-                const activeScope = getMemoryActiveScope();
-                const scope = requestedScope ?? activeScope ?? undefined;
-                const actionItems = listActionItems({
-                    scope_id: scope?.id,
-                    status: args.status,
-                    due_before: args.due_before,
-                    includeArchived: args.includeArchived,
-                });
-                return {
-                    active_scope: activeScope ? { slug: activeScope.slug, title: activeScope.title } : null,
-                    scope: scope ? { slug: scope.slug, title: scope.title } : null,
-                    action_items: actionItems.map((item) => ({
-                        id: item.id,
-                        scope_id: item.scopeId,
-                        entity_id: item.entityId,
-                        title: item.title,
-                        detail: item.detail,
-                        status: item.status,
-                        due_at: item.dueAt,
-                        snooze_until: item.snoozeUntil,
-                        source: item.source,
-                        created_at: item.createdAt,
-                        updated_at: item.updatedAt,
-                        resolved_at: item.resolvedAt,
-                        resolution_reason: item.resolutionReason,
-                    })),
-                };
-            },
-        }),
-        defineTool("memory_recall", {
-            description: "Search scoped agent memory with FTS-backed recall. Use this for the new agent-memory store, not the wiki-backed recall tool.",
-            parameters: z.object({
-                query: z.string().describe("Query text to search for."),
-                scope: z.string().optional().describe("Optional scope slug. Defaults to the active scope when available."),
-                kinds: z.array(z.enum(["observation", "decision", "entity", "action_item"])).optional()
-                    .describe("Optional filter for memory entry kinds."),
-                limit: z.number().int().positive().optional().describe("Maximum number of ranked hits to return. Defaults to 10."),
-                includeSuperseded: z.boolean().optional().describe("Include superseded observations and decisions. Defaults to false."),
-                includeArchived: z.boolean().optional().describe("Include archived observations and decisions. Defaults to false."),
-                includeCold: z.boolean().optional().describe("Include cold-tier rows. Defaults to false."),
-            }),
-            handler: async (args) => {
-                const requestedScope = args.scope ? getMemoryScope(args.scope) : undefined;
-                if (args.scope && !requestedScope) {
-                    return `Unknown memory scope '${args.scope}'.`;
-                }
-                const result = recallMemory({
-                    query: args.query,
-                    scope_id: requestedScope?.id,
-                    kinds: args.kinds,
-                    limit: args.limit ?? 10,
-                    includeSuperseded: args.includeSuperseded,
-                    includeArchived: args.includeArchived,
-                    includeCold: args.includeCold,
-                });
-                return {
-                    active_scope: result.activeScope
-                        ? { slug: result.activeScope.slug, title: result.activeScope.title }
-                        : null,
-                    hot_tier: result.hotTier,
-                    hits: result.hits.map((hit) => ({
-                        kind: hit.kind,
-                        id: hit.id,
-                        scope: hit.scope,
-                        content: hit.content,
-                        decided_at: hit.decidedAt,
-                        score: hit.score,
-                        snippet: hit.snippet,
-                    })),
-                };
-            },
-        }),
-        defineTool("memory_housekeep", {
-            description: "Run the scoped agent-memory housekeeping pipeline. Orchestrator-only write-tier maintenance tool.",
-            parameters: z.object({
-                scope_slug: z.string().optional().describe("Optional scope slug. Defaults to the active scope."),
-                all_scopes: z.boolean().optional().describe("Run scoped passes for all active scopes instead of one scope."),
-                passes: z.array(z.string()).optional().describe("Optional pass names: dedup_observations, dedup_decisions, orphan_cleanup, decay, compact_inbox."),
-            }),
-            handler: async (args) => {
-                const denied = requireOrchestratorMemoryWrite();
-                if (denied)
-                    return denied;
-                if (args.scope_slug && args.all_scopes) {
-                    return "Pass either scope_slug or all_scopes, not both.";
-                }
-                try {
-                    const requestedScope = args.scope_slug ? getMemoryScope(args.scope_slug) : undefined;
-                    if (args.scope_slug && !requestedScope) {
-                        return `Unknown memory scope '${args.scope_slug}'.`;
-                    }
-                    const result = await runHousekeeping({
-                        scopeIds: requestedScope ? [requestedScope.id] : undefined,
-                        allScopes: args.all_scopes,
-                        passes: args.passes,
-                    });
-                    return {
-                        ok: result.summaries.every((summary) => summary.errors.length === 0),
-                        scope_ids: result.scopeIds,
-                        total_examined: result.totalExamined,
-                        total_modified: result.totalModified,
-                        duration_ms: result.durationMs,
-                        summaries: result.summaries,
-                    };
-                }
-                catch (err) {
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-        defineTool("memory_reflect", {
-            description: "Synthesize durable scoped memory patterns from repeated observations. Orchestrator-only reflect tool.",
-            parameters: z.object({
-                scope: z.string().optional(),
-            }),
-            handler: async (args) => {
-                const denied = requireOrchestratorMemoryWrite();
-                if (denied)
-                    return denied;
-                try {
-                    if (args.scope) {
-                        const requestedScope = getMemoryScope(args.scope);
-                        if (!requestedScope) {
-                            return `Unknown memory scope '${args.scope}'.`;
-                        }
-                        const result = await reflectOnScope(args.scope, getDb());
-                        return {
-                            ok: true,
-                            scope: args.scope,
-                            patterns_created: result.patternsCreated,
-                            patterns_updated: result.patternsUpdated,
-                            contradictions_found: result.contradictionsFound,
-                        };
-                    }
-                    const results = await reflectAllScopes(getDb());
-                    const totals = Object.values(results).reduce((acc, result) => ({
-                        patterns_created: acc.patterns_created + result.patternsCreated,
-                        patterns_updated: acc.patterns_updated + result.patternsUpdated,
-                        contradictions_found: acc.contradictions_found + result.contradictionsFound,
-                    }), {
-                        patterns_created: 0,
-                        patterns_updated: 0,
-                        contradictions_found: 0,
-                    });
-                    return {
-                        ok: true,
-                        scope: "all",
-                        ...totals,
-                    };
-                }
-                catch (err) {
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-        defineTool("memory_promote", {
-            description: "Promote a memory row to the hot tier. Orchestrator-only manual override.",
-            parameters: z.object({
-                table: memoryTierTableSchema,
-                id: z.number().int().positive(),
-                reason: z.string().min(1),
-            }),
-            handler: async (args) => {
-                const denied = requireOrchestratorMemoryWrite();
-                if (denied)
-                    return denied;
-                try {
-                    promoteToHot(args.table, args.id, args.reason);
-                    return { ok: true, table: args.table, id: args.id, tier: "hot" };
-                }
-                catch (err) {
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-        defineTool("memory_demote", {
-            description: "Demote a memory row to warm or cold tier. Orchestrator-only manual override.",
-            parameters: z.object({
-                table: memoryTierTableSchema,
-                id: z.number().int().positive(),
-                reason: z.string().min(1),
-                tier: z.enum(["warm", "cold"]).optional().describe("Target demotion tier. Defaults to warm."),
-            }),
-            handler: async (args) => {
-                const denied = requireOrchestratorMemoryWrite();
-                if (denied)
-                    return denied;
-                try {
-                    if (args.tier === "cold") {
-                        demoteToCold(args.table, args.id, args.reason);
-                        return { ok: true, table: args.table, id: args.id, tier: "cold" };
-                    }
-                    demoteToWarm(args.table, args.id, args.reason);
-                    return { ok: true, table: args.table, id: args.id, tier: "warm" };
-                }
-                catch (err) {
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-        defineTool("memory_set_scope", {
-            description: "Set or clear the active scope for the agent-memory system. This affects default routing for memory_remember and memory_recall.",
-            parameters: z.object({
-                slug: z.string().nullable().describe("Scope slug to activate, or null to clear the active scope."),
-            }),
-            handler: async (args) => {
-                const denied = requireOrchestratorMemoryWrite();
-                if (denied)
-                    return denied;
-                try {
-                    const previousScope = getMemoryActiveScope();
-                    const nextScope = args.slug === null ? null : (getMemoryScope(args.slug) ?? null);
-                    if (args.slug !== null && !nextScope) {
-                        return `Unknown memory scope '${args.slug}'.`;
-                    }
-                    const previousSlug = previousScope?.slug ?? null;
-                    const nextSlug = nextScope?.slug ?? null;
-                    const didChange = previousSlug !== nextSlug;
-                    const sessionKey = getCurrentSessionKey();
-                    if (didChange) {
-                        maybeScheduleScopeChangeCheckpoint(sessionKey, previousScope, nextScope);
-                    }
-                    const activeScope = setMemoryActiveScope(args.slug);
-                    if (didChange) {
-                        invalidateOrchestratorSession(sessionKey);
-                        resetCheckpointSessionState(sessionKey);
-                    }
-                    return {
-                        active_scope: activeScope
-                            ? { slug: activeScope.slug, title: activeScope.title }
-                            : null,
-                    };
-                }
-                catch (err) {
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-    ];
-}
-//# sourceMappingURL=memory.js.map