Files
waggle-os/packages/server/src/local/index.ts
shumeiko.it fe2eb0f648 refactor: remove the billing tier model (P0.1)
The community edition has no monetization (ADR-0001). Remove the tier
model (packages/shared/src/tiers.ts), the requireTier middleware and every
tier gate, GET/PATCH /api/tier and the trial start, and the Stripe
integration, which depends on the tier model.

Personal features a tier used to limit are open to everyone: unlimited
workspaces and connectors, every embedding provider including LiteLLM,
per-workspace costs, Approvals. The workspace session cap is one constant
(100). Team and enterprise surfaces are hidden instead of unlocked (team
dock zone, Settings Team/Enterprise/Plan tabs, workspace Team tab);
cloud sync reports unavailable, as it did for free users.

The sidecar ignores the tier keys in config.json but does not delete them:
both editions may still share ~/.waggle.

Web billing UI is deleted: plan cards, upgrade and trial modals, payment
success route, the KVARK sales block, tier 403 handling.
2026-10-15 19:31:50 +02:00

3374 lines
150 KiB
TypeScript

import crypto from 'node:crypto';
import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import { fileURLToPath } from 'node:url';
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
import Fastify, { type FastifyInstance, type FastifyRequest } from 'fastify';
import cors from '@fastify/cors';
import fastifyStatic from '@fastify/static';
import websocket from '@fastify/websocket';
import { MindDB, MultiMind, MultiMindCache, WorkspaceManager, WaggleConfig, createEmbeddingProvider, type EmbeddingProviderConfig, type EmbeddingProviderInstance, FrameStore, SessionStore, SuppressionStore, InstallAuditStore, CronStore, AwarenessLayer, VaultStore, SkillHashStore, OptimizationLogStore, ImprovementSignalStore, HarvestSourceStore, ClaudeCodeAdapter, reconcileIndexes, TeamSync, TelemetryStore, TELEMETRY_EVENTS, ExecutionTraceStore, EvolutionRunStore, ComplianceTemplateStore, harvestSetHash, type WorkspaceConfig } from '@waggle/core';
import { corsOriginAllowed } from './cors-config.js';
import { getBoundTeamServer } from './team-server-binding.js';
import { fetchTeamServer } from './team-server-egress.js';
import { getStorageProvider } from './storage/index.js';
import { isLoopbackBind, resolveBindHost } from './net-config.js';
import { isLocalRequest } from './origin-guard.js';
import { MemoryWeaver } from '@waggle/weaver';
import {
Orchestrator,
createSystemTools,
createPlanTools,
createGitTools,
createDocumentTools,
createSpreadsheetTools,
createPresentationTools,
createPdfTools,
createSkillTools,
createSubAgentTools,
createWorkflowTools,
runAgentLoop,
parseOpenAiTextCompletion,
ensureIdentity,
loadSystemPrompt,
loadSkills,
HookRegistry,
loadHooksFromConfig,
CostTracker,
CommandRegistry,
registerWorkflowCommands,
registerMarketplaceCommands,
createCronTools,
createSearchTools,
createBrowserTools,
createLspTools,
createCliTools,
createInsightsTools,
createConnectorSearchTools,
createCrossWorkspaceTools,
McpRuntime,
McpToolRetriever,
isWithinBudget,
getRecentLogs,
setPersonaDataDir,
deliverCronResult,
createDefaultDeliveryPreferences,
buildActiveBehavioralSpec,
loadBehavioralSpecOverrides,
TraceRecorder,
HarnessTraceBridge,
safeFetch,
detectInstalledTools,
PERSONAS,
type ToolDefinition,
type LoadedSkill,
type DeliveryPreferences,
} from '@waggle/agent';
import { PluginRuntimeManager, getStarterSkillsDir, validatePluginManifest } from '@waggle/sdk';
import { MarketplaceDB, MarketplaceSync, seedMcpServers, seedNewSources } from '@waggle/marketplace';
import type { RiskLevel } from '@waggle/shared';
import { runConnectorFetch } from './connector-harvest.js';
import { writeAutoSyncSummaryFrame } from './harvest-autosync-frame.js';
import { runLoopTick } from './loop-executor.js';
import { enqueueHeldAction } from './held-action-executor.js';
import { workspaceRoutes } from './routes/workspaces.js';
import { chatRoutes, type AgentRunner } from './routes/chat.js';
import { memoryRoutes } from './routes/memory.js';
import { memoryCenterRoutes } from './routes/memory-center.js';
import { artifactRoutes } from './routes/artifacts.js';
import { settingsRoutes } from './routes/settings.js';
import { embeddingRoutes, buildEmbeddingStatusPayload } from './routes/embedding.js';
import { sessionRoutes, findUndistilledSessions, markSessionDistilled } from './routes/sessions.js';
import { knowledgeRoutes } from './routes/knowledge.js';
import { litellmRoutes } from './routes/litellm.js';
import { runMemoryLaneExtraction } from './memory-lane-cron.js';
import { VectorEnrichmentService } from './services/vector-enrichment-service.js';
import { ingestRoutes, readFileRegistry } from './routes/ingest.js';
import { mindRoutes } from './routes/mind.js';
import { agentRoutes } from './routes/agent.js';
import { skillRoutes } from './routes/skills.js';
import { skillsAliasRoutes } from './routes/skills-aliases.js';
import { skillsHygieneRoutes } from './routes/skills-hygiene.js';
import { skillsAuditRoutes } from './routes/skills-audit.js';
import { approvalRoutes } from './routes/approval.js';
import { anthropicProxyRoutes } from './routes/anthropic-proxy.js';
import { teamRoutes } from './routes/team.js';
import { taskRoutes } from './routes/tasks.js';
import { capabilitiesRoutes } from './routes/capabilities.js';
import { toolsRoutes } from './routes/tools.js';
import { externalToolRunRoutes } from './routes/external-tool-runs.js';
import { routeProposalRoutes } from './routes/route-proposals.js';
import { waggleDanceRoutes } from './routes/waggle-dance.js';
import { commandRoutes } from './routes/commands.js';
import { commandRoutes as commandCenterRoutes } from './routes/command.js';
import { homeRoutes } from './routes/home.js';
import { onboardingRoutes } from './routes/onboarding.js';
import { cronRoutes } from './routes/cron.js';
import { notificationRoutes, emitNotification, emitSubagentStatus } from './routes/notifications.js';
import { materialFingerprint } from './notification-gate.js';
import { marketplaceDevRoutes } from './routes/marketplace-dev.js';
import { marketplaceRoutes } from './routes/marketplace.js';
import {
CapabilityProposalStore,
createCapabilityProposalRoutes,
installMarketplaceApprovalIdentity,
} from './routes/capability-proposals.js';
import { agentSearchRoutes } from './routes/agent-search.js';
import { connectorRoutes } from './routes/connectors.js';
import { mcpRoutes } from './routes/mcps.js';
import { extendRoutes } from './routes/extend.js';
import { populateMcpRuntimeFromConfig } from './mcp-config.js';
import { scheduleMarketplaceBackgroundSync } from './marketplace-background-sync.js';
import { fleetRoutes } from './routes/fleet.js';
import { importRoutes } from './routes/import.js';
import { vaultRoutes } from './routes/vault.js';
import { personaRoutes } from './routes/personas.js';
import { feedbackRoutes } from './routes/feedback.js';
import { workflowRoutes } from './routes/workflows.js';
import { workspaceTemplateRoutes } from './routes/workspace-templates.js';
import { evolutionRoutes } from './routes/evolution.js';
import { exportRoutes } from './routes/export.js';
import { dataEraseRoutes } from './routes/data-erase.js';
import { costRoutes } from './routes/cost.js';
import { backupRoutes } from './routes/backup.js';
import { offlineRoutes } from './routes/offline.js';
import { weaverRoutes } from './routes/weaver.js';
import { eventRoutes, closeAuditDb, cleanupAuditEvents, emitAuditEvent } from './routes/events.js';
import { closeTeamsDb } from './routes/team.js';
import { pinRoutes } from './routes/pins.js';
import { documentRoutes } from './routes/documents.js';
import { fileRoutes } from './routes/files.js';
import { browseRoutes } from './routes/browse.js';
import { browserExtRoutes } from './routes/browser-ext.js';
import {
BROWSER_COMPANION_CREDENTIAL_VAULT_KEY,
browserCompanionCredentialMatches,
isBrowserCompanionCredentialHash,
} from './browser-companion-pairing.js';
import { telegramRoutes, pushTelegramMessage } from './routes/telegram.js';
import { ChannelManager } from './channels/manager.js';
import { runChannelChatTurn } from './channels/chat-client.js';
import { channelRoutes } from './channels/routes.js';
import { isChannelPlatform } from './channels/types.js';
import { WorkspaceTurnCoordinator } from './workspace-turn-coordinator.js';
import { IdleSessionWatcher, readRecentTranscript, buildReviewInstruction, NOTHING_TO_DO } from './idle-watcher.js';
import { DreamJournal } from './dream-journal.js';
import { dreamRoutes } from './routes/dreams.js';
import { oauthRoutes } from './routes/oauth.js';
import { waggleSignalRoutes } from './routes/waggle-signals.js';
import { providerRoutes } from './routes/providers.js';
import { profileRoutes } from './routes/profile.js';
import { telemetryRoutes } from './routes/telemetry.js';
import { agentGroupRoutes } from './routes/agent-groups.js';
import { localJobRoutes } from './routes/jobs.js';
import { agentEntityRoutes } from './routes/agents.js';
import { automationRoutes } from './routes/automations.js';
import { harvestRoutes } from './routes/harvest.js';
import { wikiRoutes } from './routes/wiki.js';
import { identityRoutes } from './routes/identity.js';
import { agentRunRoutes } from './routes/agent-run.js';
import { agentRunsRoutes } from './routes/agent-runs.js';
import { localInferenceRoutes } from './routes/local-inference.js';
import { complianceRoutes } from './routes/compliance.js';
import { OfflineManager } from './offline-manager.js';
import { listOllamaChatModelIds } from './model-availability.js';
import { log, createLogger } from './logger.js';
import { installErrorHandler } from './error-handler.js';
import { seedDefaultCrons } from './setup-crons.js';
import { registerConnectors } from './setup-connectors.js';
import {
cronScheduleHasReadOnlyViewerTarget,
securityMiddleware,
} from './security-middleware.js';
import { LocalScheduler, makeRecordExecutionCallback } from './cron.js';
import { EvolutionService, isEvolutionAutoEnabled } from './services/evolution-service.js';
import {
generateMorningBriefing,
checkStaleWorkspaces,
checkPendingTasks,
suggestCapabilities,
type ProactiveContext,
type ProactiveMessage,
} from './proactive-handlers.js';
import { generateMonthlyAssessment, saveAssessmentToMind } from './monthly-assessment.js';
import { MAX_WORKSPACE_SESSIONS, WorkspaceSessionManager } from './workspace-sessions.js';
import { EventEmitter } from 'node:events';
import { LocalJobStore } from './job-store.js';
import { AgentRunRegistry } from './agent-run-registry.js';
import { ExecutorRegistry } from './executor-registry.js';
import { hydrateProviderEnvFromVault } from './provider-env.js';
export interface LocalConfig {
port: number;
host: string;
dataDir: string; // ~/.waggle
litellmUrl: string; // http://localhost:4000
/** Immutable desktop-launch identity used to prove sidecar ownership. */
instanceId?: string;
/** Governed CLI execution — allowlist of program names the agent may run. */
cli?: { allowlist?: string[] };
/** True only when startService owns the LiteLLM child lifecycle. */
manageLiteLLM?: boolean;
/** Stable child-process port, retained even while requests use a fallback proxy. */
managedLiteLLMPort?: number;
/** Route all agent-loop traffic through this server's built-in provider proxy. */
useBuiltInProxy?: boolean;
/** False when a managed caller must resolve provider state before health probes start. */
startOfflineManagerOnListen?: boolean;
}
/** Pending approval request — resolved when user approves or denies. */
export interface PendingApproval {
resolve: (approved: boolean) => void;
toolName: string;
input: Record<string, unknown>;
timestamp: number;
riskLevel?: RiskLevel;
}
/**
* Shared agent state — initialized once at server startup,
* accessible by all route modules for feature parity with CLI.
*/
/** LLM provider health: healthy (verified), degraded (configured, not verified), unavailable */
export type LlmHealthStatus = 'healthy' | 'degraded' | 'unavailable';
/** Which LLM provider is active and its runtime health */
export interface LlmProviderStatus {
/** Which provider is handling LLM requests */
provider: 'litellm' | 'anthropic-proxy' | 'ollama';
/** Runtime health — truthful, not optimistic */
health: LlmHealthStatus;
/** Human-readable detail (e.g. "LiteLLM on port 4000" or "No API key configured") */
detail: string;
/** When this status was last checked */
checkedAt: string;
}
export interface WorkspaceCollaborationBinding {
/** Tools visible to the owning turn after persona, availability, and intent filtering. */
visibleTools: ToolDefinition[];
/** Broader policy-filtered pool from which child workers receive their tools. */
workerTools: ToolDefinition[];
runLoop: AgentRunner;
signal: AbortSignal;
runChildTransaction: (
tools: readonly ToolDefinition[],
operation: () => Promise<import('@waggle/agent').AgentResponse>,
) => Promise<import('@waggle/agent').AgentResponse>;
defaultModel: string;
}
const WORKSPACE_COLLABORATION_TOOL_NAMES = new Set([
'spawn_agent',
'list_agents',
'get_agent_result',
'compose_workflow',
'orchestrate_workflow',
'list_harnesses',
'run_harness',
]);
export type WorkspaceCollaborationToolFactory = (
workerTools: ToolDefinition[],
runLoop: AgentRunner,
defaultModel: string,
signal?: AbortSignal,
) => ToolDefinition[];
export function bindWorkspaceChildTools(
options: WorkspaceCollaborationBinding,
createTools: WorkspaceCollaborationToolFactory,
): ToolDefinition[] {
const enabledNames = new Set(options.visibleTools.map((tool) => tool.name));
const workerTools = options.workerTools.filter(
(tool) => !WORKSPACE_COLLABORATION_TOOL_NAMES.has(tool.name),
);
const childRunLoop: AgentRunner = (config) => options.runChildTransaction(
config.tools,
() => options.runLoop({ ...config, signal: options.signal }),
);
const replacements = createTools(
workerTools,
childRunLoop,
options.defaultModel,
options.signal,
).filter((tool) => enabledNames.has(tool.name));
return [
...options.visibleTools.filter(
(tool) => !WORKSPACE_COLLABORATION_TOOL_NAMES.has(tool.name),
),
...replacements,
];
}
export interface AgentState {
orchestrator: Orchestrator;
allTools: ToolDefinition[];
hookRegistry: HookRegistry;
costTracker: CostTracker;
skills: LoadedSkill[];
userSystemPrompt: string | null;
sessionHistories: Map<string, import('./routes/chat-persistence.js').ChatHistoryMessage[]>;
currentModel: string;
litellmApiKey: string;
pendingApprovals: Map<string, PendingApproval>;
/** Serializes checkout-reading/writing agent turns by canonical physical root. */
workspaceTurnCoordinator: WorkspaceTurnCoordinator;
/** Phase B.3: persistent "always allow" grant store for gated tools. */
approvalGrantStore: import('./approval-grants.js').ApprovalGrantStore;
/**
* Rebuild workspace-scoped tools (system, git, document) for a given directory.
* Optional `orchForMindTools` replaces the shared-orchestrator mind tools with a
* session-specific orchestrator's tools so concurrent sessions don't collide.
*/
buildToolsForWorkspace: (workspacePath: string, orchForMindTools?: Orchestrator, workspaceId?: string) => ToolDefinition[];
/**
* Create a fresh Orchestrator for a workspace session with the given mind mounted.
* Each session gets its own instance (Option Y fix from docs/plans/phase-a-the-room.md §9).
*/
createSessionOrchestrator: {
(): Orchestrator;
(workspaceMind: import('@waggle/core').MindDB): Orchestrator;
};
/**
* Build the full tool pool for a session, using the session's orchestrator for mind tools.
* When `sourceWorkspaceId` is provided, also injects Phase B.2 cross-workspace read tools
* (read_other_workspace, list_workspaces, list_workspace_files) scoped to that source.
*/
buildToolsForSession: (sessionOrch: Orchestrator, workspacePath: string, sourceWorkspaceId?: string) => ToolDefinition[];
/**
* Recreate collaboration producers after primitive workspace tools are lease-wrapped.
* The fresh producers run each child loop as one scope-local transaction.
*/
bindWorkspaceCollaborationTools: (options: WorkspaceCollaborationBinding) => ToolDefinition[];
/**
* Activate workspace mind for the given workspace ID. Returns true if switched.
* @deprecated — use `sessionManager.getOrCreate()` with `createSessionOrchestrator`
* and `buildToolsForSession` instead. This legacy path uses a shared orchestrator
* singleton and is unsafe for concurrent sessions. Being migrated per Phase A.1.
*/
activateWorkspaceMind: (workspaceId: string) => boolean;
/** Get a cached workspace MindDB (opens on demand). Returns null if workspace not found. */
getWorkspaceMindDb: (workspaceId: string) => import('@waggle/core').MindDB | null;
/** Close and remove a workspace MindDB from cache. Used before workspace deletion to prevent EBUSY. */
closeWorkspaceMind: (workspaceId: string) => void;
/** List all workspaces (id + name). Used by global memory search. */
listWorkspaces: () => Array<{ id: string; name: string }>;
/** Currently active workspace ID (null = personal only) */
activeWorkspaceId: string | null;
/** Current sub-agent orchestrator instance (set during workflow execution) */
subagentOrchestrator: import('@waggle/agent').SubagentOrchestrator | null;
/** Plugin runtime manager — lifecycle, tools, skills from plugins */
pluginRuntimeManager: import('@waggle/sdk').PluginRuntimeManager;
/** MCP server runtime — stdio servers, health, tools */
mcpRuntime: import('@waggle/agent').McpRuntime;
/** Steal #6: relevance-gates MCP tools into the model pool per conversation */
mcpToolRetriever: import('@waggle/agent').McpToolRetriever;
/** Command registry — slash commands */
commandRegistry: import('@waggle/agent').CommandRegistry;
/** LLM provider status — which provider is active and whether it's truly healthy */
llmProvider: LlmProviderStatus;
/** Session token for WebSocket authentication (generated on server startup) */
wsSessionToken: string;
/** SHA-256 hash of the paired Browser Companion credential, or null when unpaired. */
browserCompanionCredentialHash: string | null;
/** Memory-weaver run timestamps for the personal mind. */
weaverState: { lastPersonalConsolidation: string | null; lastPersonalDecay: string | null };
/** Per-workspace memory-weaver run timestamps, keyed by workspace ID. */
workspaceWeaverStatus: Record<string, { lastConsolidation: string | null }>;
}
declare module 'fastify' {
interface FastifyInstance {
localConfig: LocalConfig;
multiMind: MultiMind;
workspaceManager: WorkspaceManager;
eventBus: EventEmitter;
agentRunner?: AgentRunner;
agentState: AgentState;
auditStore: import('@waggle/core').InstallAuditStore;
cronStore: import('@waggle/core').CronStore;
traceStore: import('@waggle/core').ExecutionTraceStore;
evolutionStore: import('@waggle/core').EvolutionRunStore;
/**
* Active behavioral spec — baseline `BEHAVIORAL_SPEC` with any
* accepted-and-deployed evolution overrides applied. Re-derived on
* the 'behavioral-spec:reloaded' event.
*/
activeBehavioralSpec: ReturnType<typeof import('@waggle/agent').buildActiveBehavioralSpec>;
vault: import('@waggle/core').VaultStore;
embeddingProvider: import('@waggle/core').EmbeddingProviderInstance;
skillHashStore: import('@waggle/core').SkillHashStore;
scheduler: import('./cron.js').LocalScheduler;
/** Idle-session self-evolution watcher. Inert unless self-evolution.json enabled. */
idleWatcher: import('./idle-watcher.js').IdleSessionWatcher;
/** H-10 G1: autonomous evolution daemon. Inert unless WAGGLE_EVOLUTION_AUTO_ENABLED=1. */
evolutionService: import('./services/evolution-service.js').EvolutionService;
marketplace: import('@waggle/marketplace').MarketplaceDB | null;
/** Shared per-workspace mind cache. Routes use this to reach an arbitrary
* workspace's mind (e.g. FileIndexer for L-20 auto-indexing). */
mindCache: import('@waggle/core').MultiMindCache;
offlineManager: OfflineManager;
rateLimiter: import('./security-middleware.js').RateLimiter;
telemetry: import('@waggle/core').TelemetryStore;
connectorRegistry: import('@waggle/agent').ConnectorRegistry;
sessionManager: import('./workspace-sessions.js').WorkspaceSessionManager;
/**
* Bridges workflow-harness phase events into the execution trace store
* so harnessed runs become training signal for the self-evolution loop.
* Started at boot, stopped on close.
*/
harnessTraceBridge: HarnessTraceBridge;
/** Clears the cached LLM key-validation result; called by the settings route after a key update. */
_invalidateKeyValidationCache?: () => void;
}
}
const LOOPBACK_BOOTSTRAP_HOSTS = new Set(['127.0.0.1', 'localhost', '::1']);
function loopbackAuthorityMatchesRequest(
rawOrigin: string,
rawHost: string | undefined,
): boolean {
if (!rawHost) return false;
try {
const origin = new URL(rawOrigin);
const requestUrl = new URL(`http://${rawHost}`);
const originHost = origin.hostname.replace(/^\[|\]$/g, '');
const requestHost = requestUrl.hostname.replace(/^\[|\]$/g, '');
return origin.protocol === 'http:'
&& origin.username === ''
&& origin.password === ''
&& LOOPBACK_BOOTSTRAP_HOSTS.has(originHost)
&& LOOPBACK_BOOTSTRAP_HOSTS.has(requestHost)
&& origin.host === requestUrl.host;
} catch {
return false;
}
}
function browserBootstrapAuthorityAllowed(request: FastifyRequest): boolean {
const secFetchSite = request.headers['sec-fetch-site'];
if (secFetchSite !== undefined && secFetchSite !== 'same-origin') return false;
const rawOrigin = request.headers.origin ?? request.headers.referer;
if (!rawOrigin) return secFetchSite === 'same-origin';
return loopbackAuthorityMatchesRequest(rawOrigin, request.headers.host);
}
function desktopBootstrapMatches(
rawHeader: string | string[] | undefined,
expected: string | null,
): boolean {
if (!expected || typeof rawHeader !== 'string') return false;
const actualBytes = Buffer.from(rawHeader);
const expectedBytes = Buffer.from(expected);
return actualBytes.length === expectedBytes.length
&& crypto.timingSafeEqual(actualBytes, expectedBytes);
}
export async function buildLocalServer(config: Partial<LocalConfig> = {}) {
const fullConfig: LocalConfig = {
port: parseInt(process.env.WAGGLE_PORT ?? '3333'),
host: resolveBindHost(),
dataDir: config.dataDir ?? process.env.WAGGLE_DATA_DIR ?? '',
litellmUrl: config.litellmUrl ?? 'http://localhost:4000',
...config,
instanceId: config.instanceId ?? process.env.WAGGLE_INSTANCE_ID,
};
const managedDesktopBootstrap = typeof fullConfig.instanceId === 'string'
&& fullConfig.instanceId.trim().length > 0;
const rawDesktopBootstrapToken = process.env.WAGGLE_DESKTOP_BOOTSTRAP_TOKEN?.trim();
// The credential is needed only to bind this server instance to its Tauri
// launcher. Remove it before any tool discovery or child process can inherit it.
delete process.env.WAGGLE_DESKTOP_BOOTSTRAP_TOKEN;
const desktopBootstrapToken = rawDesktopBootstrapToken
&& rawDesktopBootstrapToken.length >= 32
&& rawDesktopBootstrapToken.length <= 200
? rawDesktopBootstrapToken
: null;
const server = Fastify({ logger: false });
const localJobStore = new LocalJobStore();
server.decorate('localJobStore', localJobStore);
const agentRunRegistry = new AgentRunRegistry(path.join(fullConfig.dataDir, 'agent-runs.json'));
server.decorate('agentRunRegistry', agentRunRegistry);
// ── Global error handler ──
// Fastify's own logger is disabled here, so without this an unhandled route
// exception logs nowhere and leaks raw err.message in the 500 body. One handler
// for the whole instance: 4xx pass through; 5xx log full context via `log` and
// return a generic envelope (message only outside production). See error-handler.ts.
installErrorHandler(server, log);
// Decorate with local config
server.decorate('localConfig', fullConfig);
// Set data dir for custom personas (loaded from ~/.waggle/personas/)
setPersonaDataDir(fullConfig.dataDir);
// Event bus (replaces Redis pub/sub)
const eventBus = new EventEmitter();
server.decorate('eventBus', eventBus);
// Workspace manager
const wsManager = new WorkspaceManager(fullConfig.dataDir);
const defaultWorkspaceConfig = wsManager.ensureDefault();
const defaultWorkspaceId = defaultWorkspaceConfig.id;
server.decorate('workspaceManager', wsManager);
// MultiMind — open personal mind, no workspace yet (selected via API)
const personalPath = path.join(fullConfig.dataDir, 'personal.mind');
const multiMind = new MultiMind(personalPath);
server.decorate('multiMind', multiMind);
// Install audit store — persistent trail for capability install events
const auditStore = new InstallAuditStore(multiMind.personal);
server.decorate('auditStore', auditStore);
// M-06: seed the built-in KVARK enterprise template on first boot.
// Idempotent — subsequent boots see the row and no-op.
try {
const templateStore = new ComplianceTemplateStore(multiMind.personal);
templateStore.seedKvarkTemplateIfMissing();
} catch (err) {
// Non-fatal: users can create the template manually from the UI if the
// seed fails (disk full, schema drift, etc.).
server.log.warn({ err }, 'Failed to seed KVARK compliance template');
}
// Cron store — SQLite-backed schedule persistence for Solo
const cronStore = new CronStore(multiMind.personal);
server.decorate('cronStore', cronStore);
seedDefaultCrons(cronStore);
// Execution trace store — persistent log of agent runs (self-evolution substrate)
const traceStore = new ExecutionTraceStore(multiMind.personal);
server.decorate('traceStore', traceStore);
// Workflow-harness → trace bridge. Any harness phase that completes or
// aborts anywhere in the app emits on the shared `harnessEvents` emitter;
// this bridge translates those into rows in `execution_traces` so harness
// runs become training data for the self-evolution loop.
const harnessTraceBridge = new HarnessTraceBridge({
recorder: new TraceRecorder(traceStore),
});
harnessTraceBridge.start();
server.decorate('harnessTraceBridge', harnessTraceBridge);
server.addHook('onClose', async () => {
harnessTraceBridge.stop();
});
// Evolution run store — audit trail of proposed/accepted/rejected self-evolution runs
const evolutionStore = new EvolutionRunStore(multiMind.personal);
server.decorate('evolutionStore', evolutionStore);
// Behavioral spec with deployed overrides applied (self-evolution deploy target).
// Re-derived on the 'behavioral-spec:reloaded' event emitted by evolution routes.
const initialOverrides = loadBehavioralSpecOverrides(fullConfig.dataDir);
let activeBehavioralSpec = buildActiveBehavioralSpec(initialOverrides);
server.decorate('activeBehavioralSpec', activeBehavioralSpec);
eventBus.on('behavioral-spec:reloaded', () => {
const latest = loadBehavioralSpecOverrides(fullConfig.dataDir);
activeBehavioralSpec = buildActiveBehavioralSpec(latest);
// Re-decorate so server.activeBehavioralSpec returns the fresh value.
// Fastify's decorate() is idempotent for reassignment via the instance.
(server as unknown as { activeBehavioralSpec: typeof activeBehavioralSpec }).activeBehavioralSpec = activeBehavioralSpec;
});
// Vault — encrypted secret storage
const vault = new VaultStore(fullConfig.dataDir);
server.decorate('vault', vault);
// Vault is canonical; env is the compatibility layer for provider SDKs.
let hydrated = hydrateProviderEnvFromVault(vault);
// Pass-through secrets whose vault name already matches the env var name
for (const passthrough of ['TAVILY_API_KEY', 'BRAVE_API_KEY']) {
const entry = vault.get(passthrough);
if (entry?.value && !process.env[passthrough]) {
process.env[passthrough] = entry.value;
hydrated++;
}
}
if (hydrated > 0) {
log.info(`Hydrated ${hydrated} env var(s) from vault for provider SDKs`);
}
// M2-7: Telemetry — local, opt-in, privacy-first
const waggleConfigForTelemetry = new WaggleConfig(fullConfig.dataDir);
const telemetry = new TelemetryStore(fullConfig.dataDir, waggleConfigForTelemetry.getTelemetryEnabled());
server.decorate('telemetry', telemetry);
telemetry.track(TELEMETRY_EVENTS.APP_START, { version: '0.2.0', platform: process.platform });
// embeddingProvider decorated later after creation (needs vault for API keys)
// Migrate plaintext keys from config.json to vault on first run
try {
const waggleConfig = new WaggleConfig(fullConfig.dataDir);
const configProviders = waggleConfig.getProviders();
if (Object.keys(configProviders).length > 0) {
const migrated = vault.migrateFromConfig({ providers: configProviders });
let scrubbed = 0;
for (const [name, provider] of Object.entries(configProviders)) {
if (!provider.apiKey) continue;
waggleConfig.setProvider(name, { ...provider, apiKey: '' });
scrubbed++;
}
if (scrubbed > 0) waggleConfig.save();
if (migrated > 0) {
log.info(` Migrated ${migrated} API key(s) to encrypted vault`);
}
if (scrubbed > 0) {
log.info(` Scrubbed ${scrubbed} plaintext provider key(s) from config`);
}
}
} catch {
// Migration failure should never block startup
}
// Connector Registry — manages registered connectors and generates dynamic tools
const connectorRegistry = registerConnectors(vault);
server.decorate('connectorRegistry', connectorRegistry);
// Seed marketplace.db if not present, then open it for production routes
let marketplaceDb: MarketplaceDB | null = null;
try {
const marketplaceDbTarget = path.join(fullConfig.dataDir, 'marketplace.db');
if (!fs.existsSync(marketplaceDbTarget)) {
// Packaged service.js and marketplace.db are sibling Tauri resources.
// Development and built-package candidates follow for non-Tauri runs.
// __dirname resolves to packages/server/src/local during tsx dev, and
// to packages/server/dist/local after a build — both need ../../..
// to reach the packages/ root, plus a fallback for the production bundle.
const seedPaths = [
path.resolve(__dirname, 'marketplace.db'), // packaged Tauri resource
path.resolve(__dirname, '../../../marketplace/marketplace.db'), // dev: tsx from src/local
path.resolve(__dirname, '../../../../marketplace/marketplace.db'), // built: dist/local
path.resolve(__dirname, '../../../../packages/marketplace/marketplace.db'),
path.resolve(__dirname, '../../../../../packages/marketplace/marketplace.db'),
];
for (const seedPath of seedPaths) {
if (fs.existsSync(seedPath)) {
fs.copyFileSync(seedPath, marketplaceDbTarget);
log.info(` Seeded marketplace.db from ${seedPath}`);
break;
}
}
}
if (fs.existsSync(marketplaceDbTarget)) {
marketplaceDb = new MarketplaceDB(marketplaceDbTarget);
// Seed MCP server registry entries if not already present
try {
const mcpAdded = seedMcpServers(marketplaceDb);
if (mcpAdded > 0) {
log.info(` Seeded ${mcpAdded} MCP servers into marketplace`);
}
} catch (err) {
log.warn(` MCP registry seed failed: ${(err as Error).message}`);
}
// Seed new marketplace sources (skills.sh, mcpmarket, npm, awesome-mcp-servers, etc.)
try {
const sourcesAdded = seedNewSources(marketplaceDb);
if (sourcesAdded > 0) {
log.info(` Seeded ${sourcesAdded} new marketplace sources`);
}
} catch (err) {
log.warn(` Source seed failed: ${(err as Error).message}`);
}
log.info(' Marketplace DB loaded');
}
} catch (err) {
log.warn(` Marketplace DB failed to load: ${(err as Error).message}`);
// Marketplace is optional — never block startup
}
server.decorate('marketplace', marketplaceDb);
const capabilityProposalStore = new CapabilityProposalStore();
server.decorate('capabilityProposalStore', capabilityProposalStore);
// ── Daily marketplace sync (non-blocking, 60s delay after startup) ──
const stopMarketplaceBackgroundSync = scheduleMarketplaceBackgroundSync({ marketplaceDb, log });
// ── Agent state (matches CLI initialization) ────────────────────────
const wsSessionToken = crypto.randomBytes(32).toString('hex');
const storedBrowserCompanionHash = vault.get(BROWSER_COMPANION_CREDENTIAL_VAULT_KEY)?.value;
const browserCompanionCredentialHash = isBrowserCompanionCredentialHash(storedBrowserCompanionHash)
? storedBrowserCompanionHash
: null;
const litellmApiKey = fullConfig.useBuiltInProxy
? wsSessionToken
: process.env.LITELLM_API_KEY ?? process.env.LITELLM_MASTER_KEY ?? 'sk-waggle-dev';
// Build embedding config from WaggleConfig + Vault keys
const waggleConfig = new WaggleConfig(fullConfig.dataDir || undefined);
fullConfig.cli = { allowlist: waggleConfig.getCliAllowlist() };
const embeddingConfig: EmbeddingProviderConfig = waggleConfig.getEmbeddingConfig();
// Inject API keys from encrypted Vault (never from config.json)
try {
const voyageEntry = vault.get('voyage-api-key');
if (voyageEntry?.value) embeddingConfig.voyage = { apiKey: voyageEntry.value };
} catch { /* vault may not have this key */ }
try {
const openaiEntry = vault.get('openai');
if (openaiEntry?.value) embeddingConfig.openai = { apiKey: openaiEntry.value };
} catch { /* vault may not have this key */ }
// Environment variable override for CI/headless
if (process.env.VOYAGE_API_KEY && !embeddingConfig.voyage) {
embeddingConfig.voyage = { apiKey: process.env.VOYAGE_API_KEY };
}
if (process.env.OPENAI_API_KEY && !embeddingConfig.openai) {
embeddingConfig.openai = { apiKey: process.env.OPENAI_API_KEY };
}
// Create embedding provider with InProcess → Ollama → API → Mock fallback chain
const embeddingProvider = await createEmbeddingProvider(embeddingConfig);
const embedder = embeddingProvider; // satisfies Embedder — drop-in replacement
// Decorate server with embedding provider for status endpoints
server.decorate('embeddingProvider', embeddingProvider);
const waggleHome = fullConfig.dataDir || path.join(os.homedir(), '.waggle');
const rerankerCacheDir = path.join(waggleHome, 'models', 'reranker');
// Orchestrator — connects to personal .mind
const orchestrator = new Orchestrator({
db: multiMind.personal,
embedder,
mode: 'local',
version: '0.4',
rerankerCacheDir,
});
ensureIdentity(orchestrator.getIdentity());
// Build tools — use a default workspace (homedir), but tools are rebuilt
// per-request when a workspace directory is specified in chat.
const defaultWorkspace = os.homedir();
const mindTools = orchestrator.getTools();
const systemTools = createSystemTools({
workspace: defaultWorkspace,
denySensitiveFiles: true,
});
const planTools = createPlanTools();
const gitTools = createGitTools(defaultWorkspace);
const documentTools = [
...createDocumentTools(defaultWorkspace),
...createSpreadsheetTools(defaultWorkspace),
...createPresentationTools(defaultWorkspace),
...createPdfTools(defaultWorkspace),
];
// Skill management tools — let the agent discover, install, create, and acquire skills
const starterSkillsDir = getStarterSkillsDir();
const skillTools = createSkillTools({
waggleHome,
starterSkillsDir,
auditStore,
nativeToolNames: [
...mindTools.map(t => t.name),
...systemTools.map(t => t.name),
...planTools.map(t => t.name),
...gitTools.map(t => t.name),
...documentTools.map(t => t.name),
],
getInstalledSkills: () => {
// Return the current in-memory skill state (hot-reloadable)
return server.agentState?.skills ?? loadSkills(waggleHome);
},
onSkillsChanged: () => {
// Hot-reload skills into agent state
const fresh = loadSkills(waggleHome);
// Will be set after agentState is created (see below)
reloadSkills?.(fresh);
},
searchMarketplace: async (query: string) => {
// Search the marketplace DB if available (graceful degradation)
if (!marketplaceDb) return [];
try {
const results = marketplaceDb.search({ query, limit: 10 });
return results.packages.map(pkg => ({
packageId: pkg.id,
name: pkg.name,
description: pkg.description,
packageType: pkg.package_type,
installType: pkg.waggle_install_type,
version: pkg.version,
author: pkg.author,
source: 'marketplace',
score: undefined, // FTS5 doesn't expose raw scores through our API
}));
} catch {
return [];
}
},
});
// Cron tools — let the agent manage cron schedules (via REST API).
// The chat route replaces surviving cron tools with request-bound copies so
// overlapping turns cannot exchange delivery origins.
const cronTools = createCronTools();
// Search tools — Tavily + Brave with vault-backed API keys
const searchTools = createSearchTools(async (key: string) => {
try { return vault.get(key)?.value ?? null; } catch { return null; }
});
// Browser tools — Playwright-based browser automation
const browserTools = createBrowserTools(defaultWorkspace);
// LSP tools — TypeScript language server integration
const lspTools = createLspTools(defaultWorkspace);
// CLI tools — governed CLI program execution
const cliAllowlist = fullConfig.cli?.allowlist ?? [];
const cliTools = createCliTools({
allowlist: cliAllowlist,
getAllowlist: () => fullConfig.cli?.allowlist ?? [],
});
// Dynamic connector tools (initial — regenerated per workspace in buildToolsForWorkspace)
const defaultConnectorTools = connectorRegistry.generateTools();
// Insights tools — self-analytics so the agent can reflect on its own performance.
// Aggregates optimization logs + improvement signals across the personal mind and
// every workspace so the agent sees a complete picture regardless of where it runs.
const insightsTools = createInsightsTools({
getOptimizationLogs: (limit: number) => {
const rows: Array<{
tools_used: string;
was_correction: number;
input_tokens: number;
output_tokens: number;
timestamp: string;
}> = [];
try {
rows.push(...new OptimizationLogStore(multiMind.personal).getRecent(limit));
} catch { /* personal store unavailable — keep going */ }
for (const ws of wsManager.list()) {
const wsDb = getWorkspaceMindDb(ws.id);
if (!wsDb) continue;
try {
rows.push(...new OptimizationLogStore(wsDb).getRecent(limit));
} catch { /* workspace store unavailable — skip */ }
}
rows.sort((a, b) => (b.timestamp ?? '').localeCompare(a.timestamp ?? ''));
return rows.slice(0, limit).map(row => {
let toolNames = '';
try {
const parsed = JSON.parse(row.tools_used ?? '[]');
if (Array.isArray(parsed)) toolNames = parsed.join(',');
} catch { /* malformed — leave empty */ }
return {
model: undefined,
tool_names: toolNames,
total_tokens: (row.input_tokens ?? 0) + (row.output_tokens ?? 0),
estimated_cost: 0,
was_correction: row.was_correction,
created_at: row.timestamp,
};
});
},
getImprovementSignals: () => {
const collectFrom = (db: MindDB) => {
const store = new ImprovementSignalStore(db);
return [
...store.getByCategory('capability_gap'),
...store.getByCategory('correction'),
...store.getByCategory('workflow_pattern'),
];
};
const all: Array<{
category: string;
pattern_key: string;
detail: string;
count: number;
first_seen: string;
last_seen: string;
}> = [];
try { all.push(...collectFrom(multiMind.personal)); } catch { /* skip */ }
for (const ws of wsManager.list()) {
const wsDb = getWorkspaceMindDb(ws.id);
if (!wsDb) continue;
try { all.push(...collectFrom(wsDb)); } catch { /* skip */ }
}
return all.map(s => ({
category: s.category,
pattern_key: s.pattern_key,
detail: s.detail,
count: s.count,
first_seen: s.first_seen,
last_seen: s.last_seen,
}));
},
});
// Connector search tools — give the agent natural-language discovery over
// the 148-entry MCP catalog (find_connector, list_connector_categories).
// Static data, zero I/O, no deps — cheap to always-include.
const connectorSearchTools = createConnectorSearchTools();
// Collect all non-subagent tools first (sub-agent tools need the full list)
const baseTools = [...mindTools, ...systemTools, ...planTools, ...gitTools, ...documentTools, ...skillTools, ...cronTools, ...searchTools, ...browserTools, ...lspTools, ...cliTools, ...insightsTools, ...connectorSearchTools, ...defaultConnectorTools];
// PR4: expose the full native-tool name union to the agent-search route so
// its "you already have a tool for this" lane isn't blind to search/browser/
// cli/cron/connector tools (the agent's own union omits them).
server.decorate('agentToolNames', baseTools.map(t => t.name));
// Sub-agent tools — let the main agent spawn specialist sub-agents.
// onSubAgentStatus relays start/done/error transitions to the notifications
// SSE stream so the Room canvas can render live tiles for sub-agents
// spawned via spawn_agent (bug #9). Without this wiring, sub-agents ran
// silently and Room stayed empty.
//
// onSubAgentComplete persists the result into the active mind (workspace if
// active, else personal) so specialist work survives beyond the 30-min
// in-memory eviction window — Skills 2.0 gap L.
const subAgentTools = createSubAgentTools({
availableTools: baseTools,
runLoop: runAgentLoop,
get litellmUrl() { return fullConfig.litellmUrl; },
litellmApiKey: litellmApiKey,
defaultModel: 'claude-sonnet-4-6',
onSubAgentStatus: (event) => {
emitSubagentStatus(server, server.agentState.activeWorkspaceId ?? defaultWorkspaceId, [{
id: event.agentId,
name: event.name,
role: event.role,
// emitSubagentStatus uses the workflow-orchestrator vocabulary
// ('failed' vs our internal 'error'); map at the boundary.
status: event.status === 'error' ? 'failed' : event.status,
task: event.task,
toolsUsed: event.toolsUsed,
startedAt: event.startedAt,
completedAt: event.completedAt,
}]);
},
onSubAgentComplete: async (result) => {
// Gap L — persist sub-agent result to the active mind so specialist
// work is searchable after the 30-min in-memory cache evicts.
// Best-effort: any failure is swallowed by subagent-tools so the
// main-agent-visible return path stays intact.
try {
const wsId = server.agentState.activeWorkspaceId;
const wsDb = wsId ? mindCache.getOrOpen(wsId) : null;
const targetDb = wsDb ?? multiMind.personal;
const mindLabel = wsDb ? `workspace:${wsId}` : 'personal';
// Structured content: tag provenance so search/evolution can filter
// for sub-agent-derived frames and so humans can see where it came from.
const content = `[Sub-agent: ${result.role}] ${result.agentName}\n\n${result.response}\n\n— tools: ${result.toolsUsed.join(', ') || 'none'} · ${(result.duration / 1000).toFixed(1)}s · ${result.usage.inputTokens + result.usage.outputTokens} tokens`;
// Use raw frames — cognify requires a per-mind pipeline we don't
// construct here; the decayFrames weaver will pick these up later.
const frames = new FrameStore(targetDb);
const sessions = new SessionStore(targetDb);
const active = sessions.getActive();
const gopId = active.length > 0 ? active[0].gop_id : sessions.create().gop_id;
const latestI = frames.getLatestIFrame(gopId);
if (latestI) {
frames.createPFrame(gopId, content, latestI.id, 'normal', 'agent_inferred');
} else {
frames.createIFrame(gopId, content, 'normal', 'agent_inferred');
}
log.debug(`Gap L: persisted sub-agent result ${result.agentId} to ${mindLabel} mind`);
} catch (err) {
log.debug('Gap L: sub-agent persistence failed (non-blocking)', err);
}
},
});
// Workflow tools — multi-agent workflow templates (research, review, plan-execute)
const workflowTools = createWorkflowTools({
availableTools: baseTools,
runLoop: runAgentLoop,
get litellmUrl() { return fullConfig.litellmUrl; },
litellmApiKey: litellmApiKey,
defaultModel: 'claude-sonnet-4-6',
onWorkerStatus: (event) => {
// Relay sub-agent status to eventBus for SSE notification stream
const orch = server.agentState.subagentOrchestrator;
const agents = orch ? orch.getWorkers().map(w => ({
id: w.id,
name: w.name,
role: w.role,
status: w.status,
task: w.task,
toolsUsed: w.toolsUsed,
startedAt: w.startedAt,
completedAt: w.completedAt,
})) : [{
id: event.workerId,
name: event.workerState.name,
role: event.workerState.role,
status: event.workerState.status,
task: event.workerState.task,
toolsUsed: event.workerState.toolsUsed,
startedAt: event.workerState.startedAt,
completedAt: event.workerState.completedAt,
}];
emitSubagentStatus(server, server.agentState.activeWorkspaceId ?? defaultWorkspaceId, agents);
},
});
const allTools = [...baseTools, ...subAgentTools, ...workflowTools];
// Load user customizations from ~/.waggle/
const userSystemPrompt = loadSystemPrompt(waggleHome);
const skills = loadSkills(waggleHome);
// Skill hash store — detect skill changes on disk
const skillHashStore = new SkillHashStore(multiMind.personal);
server.decorate('skillHashStore', skillHashStore);
// Check for changed skills at startup
const hashCheck = skillHashStore.checkAll(skills);
// Auto-verify new skills (first install — no change to flag)
for (const name of hashCheck.added) {
const skill = skills.find(s => s.name === name);
if (skill) skillHashStore.verify(name, skill.content);
}
// Log changed skills as warnings
if (hashCheck.changed.length > 0) {
log.info(` WARNING: ${hashCheck.changed.length} skill(s) changed on disk: ${hashCheck.changed.join(', ')}`);
log.info(' Run /skills to review changes');
}
// Clean up removed skill hashes
for (const name of hashCheck.removed) {
skillHashStore.removeHash(name);
}
// Hook registry with user-configured hooks
const hookRegistry = new HookRegistry();
await loadHooksFromConfig(path.join(waggleHome, 'hooks.json'), hookRegistry);
// Cost tracker
const costTracker = new CostTracker({});
const budgetConfig = new WaggleConfig(fullConfig.dataDir);
costTracker.setBudget(
budgetConfig.getDailyBudget(),
budgetConfig.getBudgetHardCap() ? 'hard' : 'soft',
);
const budgetDay = new Date().toISOString().slice(0, 10);
const budgetDayStart = `${budgetDay}T00:00:00.000Z`;
try {
costTracker.initializeDailyCarryover(
budgetDay,
traceStore.getTotalCostSince(budgetDayStart, traceStore.getLatestId()),
);
} catch (error) {
if (budgetConfig.getBudgetHardCap() && budgetConfig.getDailyBudget() !== null) {
throw new Error('Cannot initialize hard daily model budget from persisted spend', { cause: error });
}
server.log.warn({ err: error }, 'Persisted daily model spend unavailable');
}
// Command registry — workflow-native slash commands
const commandRegistry = new CommandRegistry();
registerWorkflowCommands(commandRegistry);
registerMarketplaceCommands(commandRegistry);
// Plugin runtime manager — lifecycle, tools, skills from plugins
const pluginRuntimeManager = new PluginRuntimeManager();
// Auto-load installed plugins from ~/.waggle/plugins/
const pluginsDir = path.join(waggleHome, 'plugins');
if (fs.existsSync(pluginsDir)) {
try {
const pluginDirs = fs.readdirSync(pluginsDir, { withFileTypes: true })
.filter(d => d.isDirectory())
.map(d => d.name);
for (const pluginName of pluginDirs) {
const pluginPath = path.join(pluginsDir, pluginName);
const manifestPath = path.join(pluginPath, 'plugin.json');
if (!fs.existsSync(manifestPath)) continue;
try {
const raw = JSON.parse(fs.readFileSync(manifestPath, 'utf-8')) as Record<string, unknown>;
const validation = validatePluginManifest(raw);
if (!validation.valid) {
log.info(` Skipping plugin "${pluginName}": invalid manifest — ${validation.errors.join(', ')}`);
continue;
}
pluginRuntimeManager.register(
raw as unknown as Parameters<typeof pluginRuntimeManager.register>[0],
{ pluginDir: pluginPath },
);
await pluginRuntimeManager.enable(raw.name as string);
} catch (err) {
log.info(` Failed to load plugin "${pluginName}": ${(err as Error).message}`);
}
}
const active = pluginRuntimeManager.getActive();
if (active.length > 0) {
log.info(` Loaded ${active.length} plugin(s): ${active.map(p => p.getManifest().name).join(', ')}`);
}
} catch { /* non-blocking — plugin scan failure must not prevent startup */ }
}
// MCP server runtime — stdio servers, health, tools.
// UX-Refactor Phase 4 (C4): populated at boot from the persisted
// <dataDir>/.mcp.json (written by the marketplace installer + /api/mcps).
// Register-only — servers stay 'stopped' until started via
// POST /api/mcps/:id/start, so boot never spawns surprise processes.
const mcpRuntime = new McpRuntime();
populateMcpRuntimeFromConfig(mcpRuntime, fullConfig.dataDir, log);
// Steal #6: relevance-gates MCP tools into the model pool. Holds the lazy
// embedding index + per-conversation union-only accumulator; the mock-embedder
// fallback keeps it honest when semantic embeddings are unavailable.
const mcpToolRetriever = new McpToolRetriever({ embedder });
// Session histories (server-side, like CLI)
const sessionHistories = new Map<string, import('./routes/chat-persistence.js').ChatHistoryMessage[]>();
// Default model — W2C: initialize from config.json's defaultModel so the
// top-bar chip and Settings → Models agree from the first launch (this was
// hardcoded, so a user whose default was e.g. Opus saw Sonnet in the chip
// until they changed it). The literal is only the last-resort fallback.
const currentModel = new WaggleConfig(fullConfig.dataDir).getDefaultModel() || 'claude-sonnet-4-6';
// Pending approvals map for confirmation gates
const pendingApprovals = new Map<string, PendingApproval>();
const workspaceTurnCoordinator = new WorkspaceTurnCoordinator();
// Phase B.3: persistent "always allow" grant store — survives sessions
// so approved (tool, target) combinations don't re-prompt every time.
const { ApprovalGrantStore } = await import('./approval-grants.js');
const approvalGrantStore = new ApprovalGrantStore(fullConfig.dataDir);
// Skill hot-reload callback is defined as a const after agentState is created
// (see `reloadSkills` below); referenced lazily from the onSkillsChanged closure.
// L-18: Resolve a FileBackend for a workspace's storage type. Team (S3/MinIO)
// workspaces return a provider-backed FileBackend so the agent's file tools
// route through the shared bucket instead of the local filesystem. Local /
// virtual workspaces return undefined — system-tools falls back to fs.*
// and existing behavior is unchanged.
const buildFileBackendForWorkspace = (workspaceId: string | undefined) => {
if (!workspaceId) return undefined;
try {
const wsMeta = wsManager.get(workspaceId);
if (!wsMeta || wsMeta.storageType !== 'team') return undefined;
const provider = getStorageProvider(
{
id: wsMeta.id,
storageType: wsMeta.storageType,
storagePath: wsMeta.storagePath,
storageConfig: (wsMeta as unknown as { storageConfig?: Record<string, unknown> }).storageConfig,
},
fullConfig.dataDir,
);
return {
read: (p: string) => provider.read(p),
write: async (p: string, data: Buffer, mime?: string) => {
await provider.write(p, data, mime);
},
exists: (p: string) => provider.exists(p),
delete: (p: string) => provider.delete(p),
};
} catch (err) {
server.log.warn({ err, workspaceId }, 'Failed to build FileBackend for workspace');
return undefined;
}
};
const createWorkspaceCollaborationTools = (
workerTools: ToolDefinition[],
runLoop: AgentRunner,
defaultModel: string,
signal?: AbortSignal,
): ToolDefinition[] => {
const workspaceSubAgentTools = createSubAgentTools({
availableTools: workerTools,
runLoop,
get litellmUrl() { return fullConfig.litellmUrl; },
litellmApiKey,
defaultModel,
onSubAgentStatus: (event) => {
emitSubagentStatus(server, server.agentState.activeWorkspaceId ?? defaultWorkspaceId, [{
id: event.agentId,
name: event.name,
role: event.role,
status: event.status === 'error' ? 'failed' : event.status,
task: event.task,
toolsUsed: event.toolsUsed,
startedAt: event.startedAt,
completedAt: event.completedAt,
}]);
},
});
const workspaceWorkflowTools = createWorkflowTools({
availableTools: workerTools,
runLoop,
get litellmUrl() { return fullConfig.litellmUrl; },
litellmApiKey,
defaultModel,
signal,
onWorkerStatus: (event) => {
const orch = server.agentState.subagentOrchestrator;
const agents = orch ? orch.getWorkers().map(w => ({
id: w.id, name: w.name, role: w.role, status: w.status,
task: w.task, toolsUsed: w.toolsUsed, startedAt: w.startedAt, completedAt: w.completedAt,
})) : [{
id: event.workerId, name: event.workerState.name, role: event.workerState.role,
status: event.workerState.status, task: event.workerState.task,
toolsUsed: event.workerState.toolsUsed, startedAt: event.workerState.startedAt,
completedAt: event.workerState.completedAt,
}];
emitSubagentStatus(server, server.agentState.activeWorkspaceId ?? defaultWorkspaceId, agents);
},
});
return [...workspaceSubAgentTools, ...workspaceWorkflowTools];
};
const bindWorkspaceCollaborationTools = (
options: WorkspaceCollaborationBinding,
): ToolDefinition[] => bindWorkspaceChildTools(options, createWorkspaceCollaborationTools);
// Factory to rebuild workspace-scoped tools for a given directory.
// Optional `orchForMindTools` replaces the shared-orchestrator mind tools with
// a session-specific orchestrator's tools (Option Y fix from Phase A.1 plan).
const buildToolsForWorkspace = (
wsPath: string,
orchForMindTools?: Orchestrator,
workspaceId?: string,
): ToolDefinition[] => {
// Dynamic connector tools (only for connected connectors)
const connectorTools = connectorRegistry.generateTools();
// Resolve which mind tools to use — per-session (if provided) or the shared default.
// Per-session is required for concurrent multi-workspace chat; the shared default
// is kept for legacy call sites that are still being migrated.
const mindToolsForRequest = orchForMindTools
? orchForMindTools.getTools()
: mindTools;
// L-18: when the workspace is team-backed, route file tools through the
// shared provider. Otherwise pass only the cwd (fs fallback).
const fileBackend = buildFileBackendForWorkspace(workspaceId);
const wsMeta = workspaceId ? wsManager.get(workspaceId) : null;
const denySensitiveFiles = Boolean(wsMeta?.directory || wsMeta?.storagePath);
const wsBase = [
...mindToolsForRequest,
...createSystemTools({ workspace: wsPath, fileBackend, denySensitiveFiles }),
...createPlanTools(),
...createGitTools(wsPath),
...createDocumentTools(wsPath),
...createSpreadsheetTools(wsPath),
...createPresentationTools(wsPath),
...createPdfTools(wsPath),
...skillTools,
...cronTools,
...searchTools,
...createBrowserTools(wsPath),
...createLspTools(wsPath),
...cliTools,
...connectorTools,
];
return [
...wsBase,
...createWorkspaceCollaborationTools(wsBase, runAgentLoop, 'claude-sonnet-4-6'),
];
};
// ── Workspace Session Manager ────────────────────────────────────
// Manages concurrent workspace sessions with independent minds, orchestrators,
// and tools.
const sessionManager = new WorkspaceSessionManager(MAX_WORKSPACE_SESSIONS);
server.decorate('sessionManager', sessionManager);
/**
* Create a fresh Orchestrator for a workspace session.
*
* Each session gets its own instance so concurrent sessions on different
* workspaces cannot corrupt each other's workspace layers via setWorkspaceMind().
* Pointer to the shared personal mind is safe — better-sqlite3 WAL mode handles
* concurrent reads and serializes writes through SQLite's internal lock.
*
* See docs/plans/phase-a-the-room.md §9 for the Option X vs Option Y decision.
*/
const createSessionOrchestrator = (workspaceMind?: MindDB): Orchestrator => {
const sessionOrch = new Orchestrator({
db: multiMind.personal,
embedder,
mode: 'local',
version: '0.4',
rerankerCacheDir,
});
if (workspaceMind) sessionOrch.setWorkspaceMind(workspaceMind);
return sessionOrch;
};
/**
* Build the tool pool for a workspace session using the session's own orchestrator
* for mind tools. Includes cross-workspace read tools (Phase B.2) that capture
* the source workspace as a closure so cross-workspace citations identify both
* sides of the access.
*/
const buildToolsForSession = (
sessionOrch: Orchestrator,
wsPath: string,
sourceWorkspaceId?: string,
): ToolDefinition[] => {
// L-18: pass sourceWorkspaceId through so buildToolsForWorkspace can resolve
// the workspace's storage type and thread a FileBackend for team storage.
const base = buildToolsForWorkspace(wsPath, sessionOrch, sourceWorkspaceId);
if (!sourceWorkspaceId) return base;
const crossTools = createCrossWorkspaceTools({
sourceWorkspaceId,
embedder,
getMindForWorkspace: (id) => mindCache.getOrOpen(id),
listWorkspaces: () => wsManager.list().map(w => ({ id: w.id, name: w.name })),
listWorkspaceFiles: async (id, subPath) => {
try {
const entries = readFileRegistry(fullConfig.dataDir, id);
// FileRegistryEntry only has name/type/summary/sizeBytes/ingestedAt —
// there's no real path hierarchy for virtual storage, so we filter by
// name prefix when a subPath is provided.
const filtered = subPath
? entries.filter(e => e.name.startsWith(subPath))
: entries;
return filtered.map(e => ({
name: e.name,
type: 'file' as const,
size: e.sizeBytes,
modifiedAt: e.ingestedAt,
}));
} catch {
return [];
}
},
});
return [...base, ...crossTools];
};
// ── Workspace mind cache (LRU, max 20 open) ──
// allowedRoot defends against path-traversal via a crafted workspaceId (review
// Critical #2 from cowork/Code-Review_MultiMind_April-2026.md). Any resolved
// path outside this root is rejected before MindDB construction.
const mindCache = new MultiMindCache({
maxOpen: 20,
getMindPath: (id) => (wsManager.get(id) ? wsManager.getMindPath(id) : null),
allowedRoot: path.join(fullConfig.dataDir, 'workspaces'),
});
server.decorate('mindCache', mindCache);
const vectorEnrichmentService = new VectorEnrichmentService({
personalMind: multiMind.personal,
embeddingProvider,
listWorkspaceIds: () => wsManager.list().map(workspace => workspace.id),
acquireWorkspaceMind: workspaceId => mindCache.acquire(workspaceId),
releaseWorkspaceMind: workspaceId => mindCache.release(workspaceId),
log: (level, message) => log[level](message),
});
let activeWorkspaceId: string | null = null;
const setActiveWorkspaceId = (workspaceId: string | null): void => {
activeWorkspaceId = workspaceId;
const decorated = (server as FastifyInstance & { agentState?: AgentState }).agentState;
if (decorated) decorated.activeWorkspaceId = workspaceId;
};
// ── TeamSync cache — one TeamSync instance per team workspace ──
const teamSyncCache = new Map<string, { sync: TeamSync; binding: string }>();
const serializeTeamSyncBinding = (
teamServer: NonNullable<ReturnType<WaggleConfig['getTeamServer']>>,
teamId: string,
): string => JSON.stringify({
url: teamServer.url,
teamId,
token: crypto.createHash('sha256').update(teamServer.token ?? '').digest('hex'),
userId: teamServer.userId ?? 'local-user',
displayName: teamServer.displayName ?? 'You',
});
function getTeamSync(workspaceId: string, wsConfig: WorkspaceConfig | null, waggleConfig: WaggleConfig): TeamSync | null {
if (!wsConfig?.teamId || !wsConfig?.teamServerUrl) {
teamSyncCache.delete(workspaceId);
return null;
}
const teamServer = getBoundTeamServer(wsConfig.teamServerUrl, waggleConfig.getTeamServer());
if (!teamServer?.token) {
teamSyncCache.delete(workspaceId);
return null;
}
const binding = serializeTeamSyncBinding(teamServer, wsConfig.teamId);
const cached = teamSyncCache.get(workspaceId);
if (cached?.binding === binding) return cached.sync;
const sync = new TeamSync({
teamServerUrl: teamServer.url,
teamSlug: wsConfig.teamId, // teamId is used as slug
authToken: teamServer.token,
userId: teamServer.userId ?? 'local-user',
displayName: teamServer.displayName ?? 'You',
}, fetchTeamServer);
const pushFrame = sync.pushFrame.bind(sync);
sync.pushFrame = async (frame) => {
const currentWorkspace = wsManager.get(workspaceId);
const currentWaggleConfig = new WaggleConfig(fullConfig.dataDir);
const currentTeamServer = getBoundTeamServer(
currentWorkspace?.teamServerUrl,
currentWaggleConfig.getTeamServer(),
);
const currentBinding = currentWorkspace?.teamId && currentTeamServer?.token
? serializeTeamSyncBinding(currentTeamServer, currentWorkspace.teamId)
: null;
const cached = teamSyncCache.get(workspaceId);
if (cached?.sync !== sync) {
return cached && currentBinding === cached.binding
? cached.sync.pushFrame(frame)
: null;
}
if (currentBinding === binding) return pushFrame(frame);
teamSyncCache.delete(workspaceId);
if (currentWorkspace?.teamId && currentTeamServer?.token) {
const replacement = getTeamSync(workspaceId, currentWorkspace, currentWaggleConfig);
if (replacement) {
if (activeWorkspaceId === workspaceId) orchestrator.setTeamSync(replacement);
return replacement.pushFrame(frame);
}
}
if (activeWorkspaceId === workspaceId) orchestrator.setTeamSync(null);
return null;
};
teamSyncCache.set(workspaceId, { sync, binding });
return sync;
}
/**
* Activate a workspace's .mind file on the orchestrator.
* Opens the mind if not cached, then calls setWorkspaceMind().
*/
const activateWorkspaceMind = (workspaceId: string): boolean => {
if (activeWorkspaceId === workspaceId) return true; // already active
if (!wsManager.get(workspaceId)) return false;
const wsDb = mindCache.getOrOpen(workspaceId);
if (!wsDb) return false;
orchestrator.setWorkspaceMind(wsDb);
setActiveWorkspaceId(workspaceId);
return true;
};
// ── Memory Weaver — background consolidation & decay (A1 fix) ────
// Runs on the personal mind at startup. Workspace minds get weavers when activated.
const personalFrames = new FrameStore(multiMind.personal);
const personalSessions = new SessionStore(multiMind.personal);
const personalWeaver = new MemoryWeaver(multiMind.personal, personalFrames, personalSessions);
const weaverTimers: NodeJS.Timeout[] = [];
const workspaceWeavers = new Map<string, { weaver: MemoryWeaver; timers: NodeJS.Timeout[] }>();
// F2: Track weaver last-run timestamps for status endpoint
const weaverState: { lastPersonalConsolidation: string | null; lastPersonalDecay: string | null } = {
lastPersonalConsolidation: null,
lastPersonalDecay: null,
};
const workspaceWeaverStatus: Record<string, { lastConsolidation: string | null }> = {};
// Run personal mind weaver on intervals
const runPersonalConsolidation = () => {
try {
const active = personalSessions.getActive();
for (const s of active) personalWeaver.consolidateGop(s.gop_id);
weaverState.lastPersonalConsolidation = new Date().toISOString();
} catch (err) { log.debug('Personal consolidation skipped', err); }
};
const runPersonalDecay = () => {
try {
personalWeaver.decayFrames();
personalWeaver.strengthenFrames();
weaverState.lastPersonalDecay = new Date().toISOString();
} catch (err) { log.debug('Personal decay skipped', err); }
};
weaverTimers.push(setInterval(runPersonalConsolidation, 60 * 60 * 1000)); // hourly
weaverTimers.push(setInterval(runPersonalDecay, 24 * 60 * 60 * 1000)); // daily
// ── Harvest auto-sync — poll stale sources every 30 min ──
const runHarvestAutoSync = async () => {
try {
const harvestStore = new HarvestSourceStore(multiMind.personal);
const stale = harvestStore.getStale();
if (stale.length === 0) return;
const { ClaudeCodeAdapter: CCA } = await import('@waggle/core');
const personalSessionStore = new SessionStore(multiMind.personal);
personalSessionStore.ensure('harvest', 'harvest', 'Imported memory from external sources');
const personalFrameStore = new FrameStore(multiMind.personal);
// #7 sticky erasure: don't re-materialize an erased subject on auto-sync.
const suppression = new SuppressionStore(multiMind.personal);
for (const src of stale) {
try {
// Only auto-sync filesystem-scannable sources
if (src.source !== 'claude-code') continue;
const homedir = (await import('node:os')).default.homedir();
const scanDir = (await import('node:path')).default.join(homedir, '.claude');
const adapter = new CCA();
const items = adapter.scan(scanDir);
if (items.length === 0) continue;
let saved = 0;
let couldNotVerify = 0;
let skippedUnsafe = 0;
for (const item of items) {
// #7 sticky erasure: distinguish a confirmed erasure MATCH from a
// fail-closed read ERROR — both skip the write, but a broken-DB read
// must be reported as "could not verify", not silently as "erased".
const supp = suppression.checkSuppressed(item.source, item.id);
if (supp.suppressed) {
if (supp.reason === 'error') couldNotVerify++;
continue; // #7 Art.17 erased (or unverifiable — fail-closed skip)
}
// #7 Art.17: stamp the subject key (metadata.sourceId) so a subject-mode
// DSAR can reach this auto-synced summary — shared with the cron path.
if (!writeAutoSyncSummaryFrame(personalFrameStore, item)) {
skippedUnsafe++;
continue;
}
saved++;
}
// R3-004: store the content digest so the manual harvest route can
// skip an unchanged re-scan on the next sync.
harvestStore.recordSync(src.source, items.length, saved, harvestSetHash(items));
log.info(`[harvest-auto-sync] ${src.source}: imported ${saved} items`
+ (couldNotVerify > 0 ? ` (${couldNotVerify} could not be verified against the erasure list — skipped, fail-closed)` : '')
+ (skippedUnsafe > 0 ? ` (${skippedUnsafe} unsafe items skipped)` : ''));
} catch (err) {
log.debug(`[harvest-auto-sync] ${src.source} failed:`, err);
}
}
} catch (err) {
log.debug('[harvest-auto-sync] skipped:', err);
}
};
weaverTimers.push(setInterval(runHarvestAutoSync, 30 * 60 * 1000)); // every 30 min
// Extend activateWorkspaceMind to also start a weaver for the workspace
// and distill any undistilled sessions into durable memory frames.
const baseActivateWorkspaceMind = activateWorkspaceMind;
const activateWorkspaceMindWithWeaver = (workspaceId: string): boolean => {
const result = baseActivateWorkspaceMind(workspaceId);
// E4: Workspace topic tracking REMOVED — was saving to personal mind, causing
// cross-workspace leakage. Workspace names are available from workspace config
// and don't need to be duplicated into memory frames.
if (result && !workspaceWeavers.has(workspaceId)) {
const wsDb = mindCache.getIfOpen(workspaceId);
if (wsDb) {
const wsFrames = new FrameStore(wsDb);
const wsSessions = new SessionStore(wsDb);
const wsWeaver = new MemoryWeaver(wsDb, wsFrames, wsSessions);
const timers: NodeJS.Timeout[] = [];
timers.push(setInterval(() => {
try {
const active = wsSessions.getActive();
for (const s of active) wsWeaver.consolidateGop(s.gop_id);
} catch { /* non-blocking */ }
}, 60 * 60 * 1000));
timers.push(setInterval(() => {
try { wsWeaver.decayFrames(); wsWeaver.strengthenFrames(); } catch (err) { log.debug('Workspace memory decay skipped', err); }
}, 24 * 60 * 60 * 1000));
workspaceWeavers.set(workspaceId, { weaver: wsWeaver, timers });
// E2: Distill undistilled sessions into durable memory frames on activation
try {
const sessionsDir = path.join(fullConfig.dataDir, 'workspaces', workspaceId, 'sessions');
const undistilled = findUndistilledSessions(sessionsDir);
for (const session of undistilled) {
const distilled = wsWeaver.distillSessionContent(session.date, session.summary, session.keyPoints);
if (distilled) markSessionDistilled(session.filePath);
}
} catch (err) { log.debug('Workspace distillation skipped', err); }
}
}
// After mind activation for team workspaces — pull remote frames
if (result) {
const wsConfig = wsManager.get(workspaceId);
if (wsConfig?.teamId) {
const sync = getTeamSync(workspaceId, wsConfig, new WaggleConfig(fullConfig.dataDir));
if (sync) {
// Set TeamSync on the orchestrator for push-on-write
orchestrator.setTeamSync(sync);
// Pull team frames into local workspace mind
const wsDb = mindCache.getIfOpen(workspaceId);
if (wsDb) {
const wsSessionStore = new SessionStore(wsDb);
wsSessionStore.ensure('team-sync', 'team-sync', 'Frames synced from team server');
const wsFrameStore = new FrameStore(wsDb);
sync.pullFrames(sync.getLastSyncTimestamp() ?? undefined).then(pulled => {
if (pulled.length === 0) return;
let inserted = 0;
for (const f of pulled) {
try {
// Provenance is carried in the content prefix ([Team:author]); the source
// column must be schema-valid, so use 'import' (these frames are imported
// from the team server). Previously passed 'team_sync', which violated the
// memory_frames.source CHECK → every pulled frame was silently skipped.
wsFrameStore.createIFrame('team-sync', `[Team:${f.authorName}] ${f.content}`, f.importance, 'import');
inserted++;
} catch { /* duplicate or constraint — skip */ }
}
if (inserted > 0) {
log.info(`TeamSync: pulled ${inserted} new frames for workspace ${workspaceId}`);
}
}).catch(err => {
log.warn(`TeamSync pull failed:`, err.message);
});
}
} else {
orchestrator.setTeamSync(null);
}
} else {
// Non-team workspace — clear TeamSync
orchestrator.setTeamSync(null);
}
}
return result;
};
// Helper: get a cached workspace MindDB (opens on demand)
// A6: Close and remove workspace mind DB from cache before deletion
const closeWorkspaceMind = (workspaceId: string): void => {
// Pin-aware: close any live session first so it drops its cache pin (and
// stops referencing a handle we're about to force-close). Then force-close
// the cache entry — on deletion the workspace is authoritative, so we close
// regardless of remaining pins to release the file lock before FS deletion
// (A6 EBUSY). Ordering avoids the old double-close where both the session
// and this seam closed the same MindDB.
sessionManager.close(workspaceId);
mindCache.close(workspaceId);
teamSyncCache.delete(workspaceId);
if (activeWorkspaceId === workspaceId) {
orchestrator.setTeamSync(null);
orchestrator.clearWorkspaceMind();
setActiveWorkspaceId(null);
}
};
const getWorkspaceMindDb = (workspaceId: string): MindDB | null => {
if (!wsManager.get(workspaceId)) return null;
return mindCache.getOrOpen(workspaceId);
};
// Decorate with shared agent state
server.decorate('agentState', {
orchestrator,
allTools,
hookRegistry,
costTracker,
skills,
userSystemPrompt,
sessionHistories,
currentModel,
litellmApiKey,
pendingApprovals,
workspaceTurnCoordinator,
approvalGrantStore,
buildToolsForWorkspace,
createSessionOrchestrator,
buildToolsForSession,
bindWorkspaceCollaborationTools,
activateWorkspaceMind: activateWorkspaceMindWithWeaver,
getWorkspaceMindDb,
closeWorkspaceMind,
listWorkspaces: () => wsManager.list().map(w => ({ id: w.id, name: w.name })),
activeWorkspaceId,
weaverState,
workspaceWeaverStatus,
subagentOrchestrator: null,
pluginRuntimeManager,
mcpRuntime,
mcpToolRetriever,
commandRegistry,
llmProvider: {
provider: 'anthropic-proxy' as const,
health: 'unavailable' as const,
detail: 'Not yet initialized',
checkedAt: new Date().toISOString(),
},
wsSessionToken,
browserCompanionCredentialHash,
});
activateWorkspaceMindWithWeaver(defaultWorkspaceId);
// Wire up skill hot-reload callback
const reloadSkills = (fresh: LoadedSkill[]) => {
server.agentState.skills.length = 0;
server.agentState.skills.push(...fresh);
};
// Dream Diary — records the nightly curation runs below so /api/dreams can
// narrate them to the user (docs/plans/DREAM-DIARY-2026-07-09.md).
const dreamJournal = new DreamJournal(fullConfig.dataDir);
server.decorate('dreamJournal', dreamJournal);
const executorRegistry = new ExecutorRegistry({
detectTools: async () => (await detectInstalledTools()).tools,
personas: () => PERSONAS,
});
server.decorate('executorRegistry', executorRegistry);
// Local scheduler — runs cron jobs in-process (Solo, no Redis/BullMQ)
const persistCronHistory = makeRecordExecutionCallback(cronStore);
// #17: hard daily bound on ai_task firings per schedule — each firing is a
// full agent turn (real LLM spend), so a runaway cron must self-limit even
// past the create-time min-interval guard.
const AI_TASK_DAILY_CAP = 24;
const scheduler = new LocalScheduler(cronStore, async (schedule) => {
switch (schedule.job_type) {
case 'memory_consolidation': {
// Check if this is a marketplace sync (uses memory_consolidation type for system-level scheduling)
const mcJobConfig = JSON.parse(schedule.job_config || '{}');
if (mcJobConfig.action === 'index_reconcile') {
try {
// Reconcile personal mind FTS/vec indexes
const result = await reconcileIndexes(multiMind.personal);
if (result.ftsFixed > 0 || result.vecFixed > 0) {
log.info(`[cron] Index reconciliation: FTS=${result.ftsFixed} vec=${result.vecFixed} fixed (personal)`);
}
// Reconcile workspace minds
let ftsTotal = result.ftsFixed;
let vecTotal = result.vecFixed;
const workspaces = wsManager.list();
for (const ws of workspaces) {
const wsDb = getWorkspaceMindDb(ws.id);
if (wsDb) {
const wsResult = await reconcileIndexes(wsDb);
if (wsResult.ftsFixed > 0 || wsResult.vecFixed > 0) {
log.info(`[cron] Index reconciliation: FTS=${wsResult.ftsFixed} vec=${wsResult.vecFixed} fixed (workspace "${ws.name}")`);
}
ftsTotal += wsResult.ftsFixed;
vecTotal += wsResult.vecFixed;
}
}
dreamJournal.record('index_reconcile', { ftsFixed: ftsTotal, vecFixed: vecTotal });
} catch (err) {
log.warn(`[cron] Index reconciliation failed: ${(err as Error).message}`);
}
} else if (mcJobConfig.action === 'marketplace_sync' && marketplaceDb) {
try {
const vaultLookup = server.vault ? (key: string) => server.vault!.get(key)?.value ?? null : undefined;
const sync = new MarketplaceSync(marketplaceDb, vaultLookup, (url, init) => safeFetch(url, init));
const results = await sync.syncAll();
const totalAdded = results.reduce((sum, r) => sum + r.added, 0);
if (totalAdded > 0) {
eventBus.emit('notification', {
type: 'notification',
timestamp: new Date().toISOString(),
title: 'Marketplace sync complete',
body: `${totalAdded} new capability${totalAdded === 1 ? '' : 's'} discovered`,
category: 'agent',
actionUrl: '/skills',
});
}
log.info(`[cron] Marketplace sync: ${totalAdded} added across ${results.length} sources`);
} catch (err) {
log.warn(`[cron] Marketplace sync failed: ${(err as Error).message}`);
}
} else if (mcJobConfig.action === 'harvest_sync') {
// Phase 7: Memory Harvest — scan registered filesystem sources for new data.
// Only filesystem-based sources (currently claude-code) can auto-sync; API-based
// sources like chatgpt/gemini require user-uploaded exports.
try {
// Frames have a FK to sessions(gop_id) — ensure the stable
// `harvest` session row exists before creating any frames.
new SessionStore(multiMind.personal).ensure('harvest', 'harvest', 'Imported memory from external sources');
const harvestStore = new HarvestSourceStore(multiMind.personal);
const personalFrames = new FrameStore(multiMind.personal);
// #7 sticky erasure: don't re-materialize an erased subject on cron sync.
const suppression = new SuppressionStore(multiMind.personal);
const stale = harvestStore.getStale();
let totalItems = 0;
let totalFrames = 0;
let sourcesScanned = 0;
let totalCouldNotVerify = 0;
let totalSkippedUnsafe = 0;
for (const src of stale) {
if (src.source !== 'claude-code' || !src.sourcePath) continue;
try {
const adapter = new ClaudeCodeAdapter();
const items = adapter.scan(src.sourcePath);
let saved = 0;
for (const item of items) {
// #7 sticky erasure: a fail-closed read ERROR is skipped like a
// MATCH but tallied separately (report "could not verify", not "erased").
const supp = suppression.checkSuppressed(item.source, item.id);
if (supp.suppressed) {
if (supp.reason === 'error') totalCouldNotVerify++;
continue; // #7 Art.17 erased (or unverifiable — fail-closed skip)
}
// #7 Art.17: stamp the subject key (metadata.sourceId) so a
// subject-mode DSAR reaches this cron-synced summary — shared helper.
if (!writeAutoSyncSummaryFrame(personalFrames, item)) {
totalSkippedUnsafe++;
continue;
}
saved++;
}
// R3-004: store the content digest for next-sync skip.
harvestStore.recordSync(src.source, items.length, saved, harvestSetHash(items));
totalItems += items.length;
totalFrames += saved;
sourcesScanned++;
} catch (innerErr) {
log.warn(`[cron] Harvest sync: source "${src.source}" failed: ${(innerErr as Error).message}`);
}
}
if (sourcesScanned > 0) {
log.info(`[cron] Harvest sync: ${totalFrames} frames from ${totalItems} items across ${sourcesScanned} source(s)`
+ (totalCouldNotVerify > 0 ? ` (${totalCouldNotVerify} could not be verified against the erasure list — skipped, fail-closed)` : '')
+ (totalSkippedUnsafe > 0 ? ` (${totalSkippedUnsafe} unsafe items skipped)` : ''));
}
dreamJournal.record('harvest_sync', {
framesSaved: totalFrames,
itemsScanned: totalItems,
sourcesScanned,
couldNotVerify: totalCouldNotVerify,
});
} catch (err) {
log.warn(`[cron] Harvest sync failed: ${(err as Error).message}`);
}
} else if (mcJobConfig.action === 'memory_compact') {
// Phase 9a: Memory compaction — prune temporary/deprecated frames, merge stale P-frames.
// Runs across personal mind and every workspace mind.
try {
const personalResult = new FrameStore(multiMind.personal).compact();
let wsTempPruned = 0;
let wsDepPruned = 0;
let wsMerged = 0;
for (const ws of wsManager.list()) {
const wsDb = getWorkspaceMindDb(ws.id);
if (!wsDb) continue;
try {
const r = new FrameStore(wsDb).compact();
wsTempPruned += r.temporaryPruned;
wsDepPruned += r.deprecatedPruned;
wsMerged += r.pframesMerged;
} catch (innerErr) {
log.warn(`[cron] Memory compaction: workspace "${ws.name}" failed: ${(innerErr as Error).message}`);
}
}
dreamJournal.record('memory_compact', {
temporaryPruned: personalResult.temporaryPruned + wsTempPruned,
deprecatedPruned: personalResult.deprecatedPruned + wsDepPruned,
pframesMerged: personalResult.pframesMerged + wsMerged,
});
const total =
personalResult.temporaryPruned + personalResult.deprecatedPruned + personalResult.pframesMerged +
wsTempPruned + wsDepPruned + wsMerged;
if (total > 0) {
log.info(
`[cron] Memory compaction: personal(temp=${personalResult.temporaryPruned}, dep=${personalResult.deprecatedPruned}, merged=${personalResult.pframesMerged}) ` +
`workspaces(temp=${wsTempPruned}, dep=${wsDepPruned}, merged=${wsMerged})`
);
}
} catch (err) {
log.warn(`[cron] Memory compaction failed: ${(err as Error).message}`);
}
} else if (mcJobConfig.action === 'memory_lane_extract') {
// W4.3d: extraction of the benchmark-proven recall lanes
// (facts/events/profiles) over frames written since the last run.
// Routes through the built-in proxy ('fast' tier = haiku) — the
// same internal-LLM pattern as prompt_optimization above.
try {
const llmCall = async (prompt: string, _model: 'fast' | 'accurate'): Promise<string> => {
const proxyUrl = `http://127.0.0.1:${fullConfig.port ?? 3333}/v1/chat/completions`;
const res = await fetch(proxyUrl, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
signal: AbortSignal.timeout(90_000),
body: JSON.stringify({
model: 'claude-haiku-4-5',
max_tokens: 4096,
messages: [{ role: 'user', content: prompt }],
}),
});
if (!res.ok) throw new Error(`lane-extract LLM HTTP ${res.status}`);
const data = await res.json() as unknown;
return parseOpenAiTextCompletion(data).content;
};
const minds: Array<{ label: string; db: import('@waggle/core').MindDB }> = [
{ label: 'personal', db: multiMind.personal },
];
for (const ws of wsManager.list()) {
const wsDb = getWorkspaceMindDb(ws.id);
if (wsDb) minds.push({ label: `workspace "${ws.name}"`, db: wsDb });
}
let laneFramesProcessed = 0;
let laneFacts = 0;
let laneEvents = 0;
let laneProfiles = 0;
for (const mind of minds) {
try {
const r = await runMemoryLaneExtraction(mind.db, llmCall);
if (!r.skipped) {
if (r.errors.length > 0) {
log.warn(
`[cron] Memory lanes (${mind.label}) incomplete; watermark held for retry: ` +
r.errors.join('; ').slice(0, 200)
);
continue;
}
log.info(
`[cron] Memory lanes (${mind.label}): ${r.framesProcessed} frames → ` +
`facts=${r.written?.factsWritten ?? 0} events=${r.written?.eventsWritten ?? 0} ` +
`profiles=${r.written?.profilesWritten ?? 0}` +
(r.errors.length ? ` (errors: ${r.errors.join('; ').slice(0, 200)})` : '')
);
laneFramesProcessed += r.framesProcessed;
laneFacts += r.written?.factsWritten ?? 0;
laneEvents += r.written?.eventsWritten ?? 0;
laneProfiles += r.written?.profilesWritten ?? 0;
}
} catch (innerErr) {
log.warn(`[cron] Memory lanes (${mind.label}) failed: ${(innerErr as Error).message}`);
}
}
dreamJournal.record('memory_lane_extract', {
framesProcessed: laneFramesProcessed,
factsWritten: laneFacts,
eventsWritten: laneEvents,
profilesWritten: laneProfiles,
});
} catch (err) {
log.warn(`[cron] Memory lane extraction failed: ${(err as Error).message}`);
}
} else {
// Normal memory consolidation
try { runPersonalConsolidation(); } catch { /* non-blocking */ }
}
// UX-Refactor Phase 3: cron_execution_history retention. recordExecution
// now writes a row per tick (Journey 16), so prune >30-day rows on the
// same nightly consolidation cadence (mirrors optStore.pruneOlderThan).
try { cronStore.pruneExecutionHistory(30); } catch { /* best-effort */ }
// L2: flip held actions past their 7-day TTL to 'expired' so stale
// proposals stop being approvable and the queue doesn't grow unbounded.
try { cronStore.expireStalePendingActions(); } catch { /* best-effort */ }
break;
}
case 'workspace_health':
// Log stale frame count per workspace as awareness flag
try {
const workspaces = wsManager.list();
for (const ws of workspaces) {
const wsDb = getWorkspaceMindDb(ws.id);
if (wsDb) {
const wsFrames = new FrameStore(wsDb);
const staleCount = wsFrames.list({ limit: 100 })
.filter(f => {
const age = Date.now() - new Date(f.last_accessed).getTime();
return age > 7 * 24 * 60 * 60 * 1000;
}).length;
if (staleCount > 0) {
const wsAwareness = new AwarenessLayer(wsDb);
wsAwareness.add('flag', `Workspace "${ws.name}" has ${staleCount} stale memory frames (>7 days untouched)`, 0);
}
}
}
} catch { /* non-blocking */ }
break;
case 'proactive': {
const proactiveConfig = JSON.parse(schedule.job_config || '{}');
const proactiveCtx: ProactiveContext = {
dataDir: fullConfig.dataDir,
workspaceManager: wsManager,
getWorkspaceMindDb,
};
/** Emit a ProactiveMessage through the delivery router pipeline. */
const emitProactive = (msg: ProactiveMessage) => {
// Load delivery preferences from config (or use defaults)
let deliveryPrefs: DeliveryPreferences;
try {
const configPath = path.join(fullConfig.dataDir, 'delivery-preferences.json');
if (fs.existsSync(configPath)) {
deliveryPrefs = { ...createDefaultDeliveryPreferences(), ...JSON.parse(fs.readFileSync(configPath, 'utf-8')) };
} else {
deliveryPrefs = createDefaultDeliveryPreferences();
}
} catch {
deliveryPrefs = createDefaultDeliveryPreferences();
}
const inAppEmitter = (notification: { title: string; body: string; category: string; actionUrl?: string }) => {
emitNotification(
server,
{ ...notification, category: notification.category as 'cron' | 'agent' | 'task' },
msg.dedupeKey && msg.materialHash ? { dedupeKey: msg.dedupeKey, materialHash: msg.materialHash } : undefined,
);
};
deliverCronResult(
{ title: msg.title, body: msg.body, jobType: msg.type, workspaceId: msg.workspaceId, priority: msg.priority },
deliveryPrefs,
server.connectorRegistry,
inAppEmitter,
).catch(err => log.warn(`[cron-delivery] Delivery failed: ${(err as Error).message}`));
};
try {
switch (proactiveConfig.action) {
case 'morning_briefing': {
const briefing = generateMorningBriefing(proactiveCtx);
if (briefing) emitProactive(briefing);
break;
}
case 'stale_workspace_check': {
const staleAlerts = checkStaleWorkspaces(proactiveCtx);
for (const alert of staleAlerts) emitProactive(alert);
break;
}
case 'task_reminder': {
const reminders = checkPendingTasks(proactiveCtx);
for (const reminder of reminders) emitProactive(reminder);
break;
}
case 'capability_suggestion': {
const suggestion = suggestCapabilities(proactiveCtx);
if (suggestion) emitProactive(suggestion);
break;
}
default:
log.warn(`[cron] Unknown proactive action: ${proactiveConfig.action}`);
}
} catch (err) {
log.warn(`[cron] Proactive handler failed: ${(err as Error).message}`);
}
break;
}
case 'prompt_optimization': {
// Background GEPA/Ax prompt optimization — runs daily at 2 AM.
// Iterates workspaces with optimizationEnabled, checks budget, reads logs,
// and invokes PromptOptimizer for variant generation.
try {
const workspaces = wsManager.list().filter(ws => ws.optimizationEnabled);
for (const ws of workspaces) {
const wsDb = getWorkspaceMindDb(ws.id);
if (!wsDb) continue;
const optStore = new OptimizationLogStore(wsDb);
const budget = ws.optimizationBudget ?? 100; // cents, default $1/day
// Check budget before spending any tokens
if (!isWithinBudget(optStore, budget)) {
log.info(`[cron] Prompt optimization: workspace "${ws.name}" over budget, skipping`);
continue;
}
// Read recent logs for analysis
const recentLogs = getRecentLogs(optStore, 100);
if (recentLogs.length < 5) {
// Not enough data to optimize yet
continue;
}
// Analyze patterns: high correction rate, common tools, avg turn count
const stats = optStore.getStats();
const correctionRate = stats.correctionRate;
const avgTurns = stats.avgTurnCount;
// Only trigger optimization if correction rate is above threshold
// or turn count is significantly above average (indicating inefficiency)
if (correctionRate > 0.2 || avgTurns > 15) {
const rate = (correctionRate * 100).toFixed(1);
log.info(`[cron] Prompt optimization: workspace "${ws.name}" — correction rate ${rate}%, avg turns ${avgTurns.toFixed(1)}`);
// Re-check budget before the LLM call (another workspace may have consumed tokens)
if (!isWithinBudget(optStore, budget)) {
log.info(` GEPA optimization skipped — daily budget exceeded`);
continue;
}
// Get the most recent system prompt from the workspace's logs
const currentSystemPrompt = recentLogs[0]?.system_prompt ?? '';
if (!currentSystemPrompt) {
log.info(`[cron] Prompt optimization: no system prompt in logs, skipping`);
continue;
}
// Generate variant via the built-in Anthropic proxy (localhost)
try {
const proxyUrl = `http://127.0.0.1:${fullConfig.port ?? 3333}/v1/chat/completions`;
const variantResponse = await fetch(proxyUrl, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
model: 'claude-sonnet-4-6',
max_tokens: 4096,
messages: [
{
role: 'system',
content: `You are a prompt optimization specialist. Your task is to improve an AI agent's system prompt based on performance signals.
The agent's correction rate is ${rate}% (target: under 20%) and average turn count is ${avgTurns.toFixed(1)} (target: under 15).
A high correction rate means the agent frequently misunderstands instructions or produces wrong outputs.
A high turn count means the agent takes too many steps to complete tasks.
Analyze the current system prompt and generate an improved variant that:
1. Adds clearer instructions for areas where corrections are common
2. Reduces unnecessary verbosity that inflates turn count
3. Preserves the core identity and capabilities
4. Is production-ready (not a draft or explanation)
Return ONLY the improved system prompt text. No commentary, no markdown fences, no explanation.`,
},
{
role: 'user',
content: `Here is the current system prompt to improve:\n\n${currentSystemPrompt.slice(0, 12000)}`,
},
],
}),
signal: AbortSignal.timeout(60_000),
});
if (!variantResponse.ok) {
log.warn(`[cron] GEPA variant generation failed: HTTP ${variantResponse.status}`);
} else {
const variantBody = await variantResponse.json() as unknown;
const variantText = parseOpenAiTextCompletion(variantBody).content;
if (variantText.length > 100) {
// Store the variant in the optimization_log with a marker
optStore.insert({
sessionId: `gepa-variant-${Date.now()}`,
workspaceId: ws.id,
systemPrompt: variantText,
toolsUsed: ['gepa_variant'],
turnCount: 0,
wasCorrection: false,
inputTokens: currentSystemPrompt.length,
outputTokens: variantText.length,
});
log.info(` GEPA generated prompt variant (correction_rate=${rate}%)`);
} else {
log.warn(`[cron] GEPA variant too short (${variantText.length} chars), discarding`);
}
}
} catch (variantErr) {
log.warn(`[cron] GEPA variant generation error: ${(variantErr as Error).message}`);
}
// Anti-nag: one signal per (workspace, month, correction-rate bucket).
// Re-runs on the same month with an unchanged rate bucket are suppressed.
emitNotification(server, {
title: 'Prompt optimization signal',
body: `Workspace "${ws.name}" has ${(correctionRate * 100).toFixed(0)}% correction rate — optimization candidate`,
category: 'agent',
}, {
dedupeKey: `prompt_optimization:${ws.id}`,
materialHash: materialFingerprint({
wsId: ws.id,
period: new Date().toISOString().slice(0, 7),
rateBucket: Math.round(correctionRate * 10),
}),
});
}
// Prune old logs (>30 days) to keep the .mind file lean
optStore.pruneOlderThan(30);
}
} catch (err) {
log.warn(`[cron] Prompt optimization failed: ${(err as Error).message}`);
}
break;
}
case 'agent_task': {
// F9: Execute an agent task prompt in a workspace context
const taskConfig = JSON.parse(schedule.job_config || '{}');
const taskPrompt = taskConfig.prompt as string | undefined;
const taskWorkspace = schedule.workspace_id;
if (!taskPrompt) {
log.warn(`[cron] agent_task "${schedule.name}" has no prompt in job_config, skipping`);
break;
}
try {
// Determine target workspaces: "*" means all, otherwise single workspace
const targetWorkspaces: Array<{ id: string; name: string }> = [];
if (taskWorkspace === '*') {
// F30: Global/cross-workspace — iterate all workspaces
const allWs = wsManager.list();
for (const ws of allWs) {
targetWorkspaces.push({ id: ws.id, name: ws.name });
}
} else if (taskWorkspace) {
const ws = wsManager.get(taskWorkspace);
if (ws) {
targetWorkspaces.push({ id: ws.id, name: ws.name });
} else {
log.warn(`[cron] agent_task "${schedule.name}" references unknown workspace "${taskWorkspace}"`);
}
}
if (targetWorkspaces.length === 0) {
log.warn(`[cron] agent_task "${schedule.name}" has no valid target workspaces`);
break;
}
// #17 ai_task daily cap: every firing is a full agent turn (real
// LLM spend) — bound runaway schedules regardless of cron expr.
if (taskConfig.mode === 'ai_task'
&& cronStore.countExecutionsToday(schedule.id) >= AI_TASK_DAILY_CAP) {
log.warn(`[cron] ai_task "${schedule.name}" skipped — daily cap (${AI_TASK_DAILY_CAP}) reached`);
break;
}
let aiTaskSucceeded = false;
const targetErrors: unknown[] = [];
for (const target of targetWorkspaces) {
try {
// Activate workspace mind so agent has context
activateWorkspaceMindWithWeaver(target.id);
if (taskConfig.mode === 'ai_task') {
// #17: full agent turn through the loopback chat route —
// tools, memory recall, governance, approval-gated writes
// HELD (proposeHeld). origin:'automation' (#13) keeps the
// scheduled turn out of memory write-back. Legacy rows
// without mode keep the toolless completion path below.
const turn = await runChannelChatTurn({
port: fullConfig.port ?? 3333,
sessionToken: server.agentState.wsSessionToken,
message: `[Scheduled task "${schedule.name}" for workspace "${target.name}"]\n\n${taskPrompt}`,
workspace: target.id,
session: `schedule-${schedule.id}`,
proposeHeld: true,
origin: 'automation',
});
const output = turn.content || '';
if (!turn.error) aiTaskSucceeded = true;
// Delivery: origin channel first (stamped from the trusted
// turn-origin snapshot at create time), notification always.
const deliverTo = taskConfig.deliverTo as { platform?: string; chatId?: string } | undefined;
if (!turn.error && deliverTo?.platform && deliverTo?.chatId && output && isChannelPlatform(deliverTo.platform)) {
const sent = await server.channelManager
?.sendTo(deliverTo.platform, deliverTo.chatId, `[${schedule.name}]\n${output}`)
.catch((e: unknown) => {
log.warn(`[cron] ai_task "${schedule.name}" channel delivery failed: ${e instanceof Error ? e.message : e}`);
return false;
});
if (!sent) log.warn(`[cron] ai_task "${schedule.name}" delivery skipped — ${deliverTo.platform} adapter not running`);
}
const summary = output.length > 200 ? output.slice(0, 197) + '...' : output;
emitNotification(server, {
title: `Scheduled task: ${schedule.name}`,
body: turn.error ? `Error: ${turn.error}` : (summary || 'Task completed'),
category: 'cron',
actionUrl: `/workspaces/${target.id}`,
});
if (turn.error) {
throw new Error(`ai_task failed for workspace "${target.name}": ${turn.error}`);
} else {
log.info(`[cron] ai_task "${schedule.name}" completed for workspace "${target.name}" (${output.length} chars)`);
}
continue;
}
// Use the built-in Anthropic proxy to process the prompt
const proxyUrl = `http://127.0.0.1:${fullConfig.port ?? 3333}/v1/chat/completions`;
const response = await fetch(proxyUrl, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
model: server.agentState.currentModel ?? 'claude-sonnet-4-6',
max_tokens: 2048,
messages: [
{
role: 'user',
content: `[Scheduled task for workspace "${target.name}"]\n\n${taskPrompt}`,
},
],
}),
signal: AbortSignal.timeout(120_000),
});
if (response.ok) {
const body = await response.json() as unknown;
const output = parseOpenAiTextCompletion(body).content;
const summary = output.length > 200 ? output.slice(0, 197) + '...' : output;
emitNotification(server, {
title: `Scheduled task: ${schedule.name}`,
body: summary || 'Task completed',
category: 'cron',
actionUrl: `/workspaces/${target.id}`,
});
log.info(`[cron] agent_task "${schedule.name}" completed for workspace "${target.name}" (${output.length} chars)`);
} else {
throw new Error(`agent_task LLM call failed: HTTP ${response.status}`);
}
} catch (wsErr) {
log.warn(`[cron] agent_task "${schedule.name}" failed for workspace "${target.name}": ${(wsErr as Error).message}`);
targetErrors.push(wsErr);
}
}
if (targetErrors.length === 1) throw targetErrors[0];
if (targetErrors.length > 1) {
throw new AggregateError(targetErrors, `agent_task failed in ${targetErrors.length} workspaces`);
}
// #17 once mode: one-shot ai_task disables itself after the first
// successful run (row kept for execution history).
if (taskConfig.mode === 'ai_task' && taskConfig.once === true && aiTaskSucceeded) {
cronStore.update(schedule.id, { enabled: false });
log.info(`[cron] ai_task "${schedule.name}" was one-shot — schedule disabled after successful run`);
}
} catch (err) {
log.warn(`[cron] agent_task handler failed: ${(err as Error).message}`);
throw err;
}
break;
}
case 'connector_fetch': {
// Auto-fetch (§3.C): pull fresh data from opted-in connectors into the
// personal mind. Cost-free — raw frames, no LLM extraction. Free (Solo).
try {
new SessionStore(multiMind.personal).ensure('harvest', 'harvest', 'Imported memory from external sources');
const personalFrames = new FrameStore(multiMind.personal);
const statePath = path.join(fullConfig.dataDir, 'connector-harvest-state.json');
const r = await runConnectorFetch({
connectors: connectorRegistry.getConnected(),
writeFrame: (content) => { personalFrames.createIFrame('harvest', content, 'normal', 'import'); },
loadState: () => {
try {
const raw = JSON.parse(fs.readFileSync(statePath, 'utf-8')) as Partial<{ lastFetchedAt: string; hashes: Record<string, string> }>;
return { lastFetchedAt: raw.lastFetchedAt, hashes: raw.hashes ?? {} };
} catch { return { hashes: {} }; }
},
saveState: (s) => {
try { fs.writeFileSync(statePath, JSON.stringify(s)); } catch { /* best-effort */ }
},
// Safety floor: at most one real sweep per ~20h even if the cron
// expression is mis-set tight (auto-fetch is a daily cadence by design).
minIntervalMs: 20 * 60 * 60 * 1000,
log: (m) => log.info(`[cron] connector_fetch: ${m}`),
});
if (r.skippedByFloor) {
log.info('[cron] connector_fetch: within frequency floor — skipped');
} else {
log.info(`[cron] connector_fetch: ${r.framesWritten} frames from ${r.connectorsFetched} connector(s); ${r.skippedUnchanged} unchanged, ${r.skippedUnsafe} unsafe, ${r.errors.length} error(s)`);
}
} catch (err) {
log.warn(`[cron] connector_fetch failed: ${err instanceof Error ? err.message : String(err)}`);
}
break;
}
case 'monthly_assessment': {
try {
const assessment = generateMonthlyAssessment(fullConfig, multiMind.personal);
saveAssessmentToMind(multiMind.personal, assessment);
log.info(`[cron] Monthly assessment for ${assessment.period}: ${assessment.totalInteractions} interactions, ${(assessment.correctionRate * 100).toFixed(1)}% correction rate`);
emitNotification(server, {
title: 'Monthly agent assessment ready',
body: `${assessment.period} report: ${assessment.totalInteractions} interactions, ${(assessment.correctionRate * 100).toFixed(1)}% correction rate — check your workspace home`,
category: 'agent',
actionUrl: '/',
}, {
// Anti-nag: one per period + counters. Same month with unchanged
// counters is suppressed; a new month or changed numbers re-fires.
dedupeKey: 'monthly_assessment',
materialHash: materialFingerprint({
period: assessment.period,
totalInteractions: assessment.totalInteractions,
correctionRateBucket: Math.round(assessment.correctionRate * 100),
}),
});
} catch (err) {
log.warn(`[cron] Monthly assessment failed: ${(err as Error).message}`);
}
break;
}
case 'loop': {
// Loop v0 (L1, report-only): a stateful, memory-powered scheduled
// automation. Resolve the target mind (a specific workspace, else the
// personal mind), build a toolless completion against the local proxy,
// and delegate to runLoopTick (recall → maker → checker → memory write).
// Throws from the maker/checker LLM path are intentionally NOT caught
// here so the scheduler records the failure and auto-disables after
// repeated failures (recall/write failures are caught inside runLoopTick).
const wsId = schedule.workspace_id;
const mindDb = wsId && wsId !== '*' ? getWorkspaceMindDb(wsId) : multiMind.personal;
if (!mindDb) {
log.warn(`[cron] loop "${schedule.name}" references unknown workspace "${wsId}" — skipping`);
break;
}
if (wsId && wsId !== '*') activateWorkspaceMindWithWeaver(wsId);
const loopModel = server.agentState.currentModel ?? 'claude-sonnet-4-6';
const loopProxyUrl = `http://127.0.0.1:${fullConfig.port ?? 3333}/v1/chat/completions`;
const loopChat = async (prompt: string, maxTokens = 2048): Promise<string> => {
const resp = await fetch(loopProxyUrl, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
model: loopModel,
max_tokens: maxTokens,
messages: [{ role: 'user', content: prompt }],
}),
signal: AbortSignal.timeout(120_000),
});
if (!resp.ok) throw new Error(`Loop LLM call failed: HTTP ${resp.status}`);
const body = await resp.json() as unknown;
return parseOpenAiTextCompletion(body).content;
};
const loopResult = await runLoopTick({ schedule, mindDb, embedder, chat: loopChat, log });
if (!loopResult.skipped) {
emitNotification(server, {
title: `Loop: ${schedule.name}`,
body: loopResult.summary || 'Loop ran',
category: 'cron',
actionUrl: wsId && wsId !== '*' ? `/workspaces/${wsId}` : '/',
});
log.info(`[cron] loop "${schedule.name}" ran${loopResult.score !== undefined ? ` (score ${loopResult.score.toFixed(2)})` : ''}${loopResult.wrote ? ', wrote 1 frame' : ''}`);
// L2 assist mode: hold the maker's proposed action for human approval.
// enqueueHeldAction validates (allowlist + critical + injection) and
// persists 'held'; nothing executes until a human approves.
if (loopResult.proposedAction) {
const enq = enqueueHeldAction(server, {
workspaceId: wsId ?? null,
source: `loop:${schedule.id}`,
tool: loopResult.proposedAction.tool,
args: loopResult.proposedAction.args,
summary: loopResult.proposedAction.summary || undefined,
});
log.info(
'refused' in enq
? `[cron] loop "${schedule.name}" proposed ${loopResult.proposedAction.tool} — refused (${enq.refused})`
: `[cron] loop "${schedule.name}" proposed ${loopResult.proposedAction.tool} — held for approval (${enq.id})`,
);
}
}
break;
}
}
}, (schedule, result) => {
// UX-Refactor Phase 3 (Journey 16): persist the execution outcome to
// cron_execution_history. Until now recordExecution was never called, so
// GET /api/cron/:id/history, /api/automations/:id/logs and the Home
// overnight failure feed all read an empty table. Fires for scheduler
// ticks AND manual triggers (executeJob); the C26 /api/automations/test
// preview is validation-only and never reaches the executor. The
// persistence closure is the shared makeRecordExecutionCallback (cron.ts)
// so automations.test.ts exercises the SAME code, not a hand-copied mirror.
persistCronHistory(schedule, result);
// Q16:C — Emit notification after every cron job tick (success or failure)
if (result.success) {
emitNotification(server, {
title: `${schedule.name || 'Scheduled task'} completed`,
body: 'Scheduled task ran successfully.',
category: 'cron',
actionUrl: '/settings/mission-control',
});
} else {
emitNotification(server, {
title: `${schedule.name || 'Scheduled task'} failed`,
body: `Error: ${result.error ?? 'Unknown error'}`,
category: 'cron',
actionUrl: '/settings/mission-control',
});
}
// FR-2 §runtime · 2026-05-28 addictiveness audit. When the user
// sets `outputChannel: 'telegram'` in a schedule's job_config,
// push a one-line digest line to their Telegram so the cron
// becomes a daily-driver hook for personas P6/P8/P10. Fire-and-
// forget — the catch ensures a Telegram outage never crashes
// the scheduler tick.
try {
const cfg = JSON.parse(schedule.job_config || '{}') as { outputChannel?: string };
if (cfg.outputChannel === 'telegram') {
const name = schedule.name || 'Scheduled task';
const expr = schedule.cron_expr ? ` (${schedule.cron_expr})` : '';
const text = result.success
? `✓ Waggle: ${name}${expr} ran successfully.`
: `✗ Waggle: ${name}${expr} failed — ${result.error ?? 'unknown error'}`;
pushTelegramMessage(server, text)
.then(r => { if (!r.ok) log.warn(`[cron→telegram] skipped: ${r.reason}`); })
.catch(err => log.warn(`[cron→telegram] push failed: ${err}`));
}
} catch (err) {
log.warn(`[cron→telegram] config parse failed: ${err}`);
}
}, notification => {
emitNotification(server, {
...notification,
category: 'cron',
actionUrl: '/settings/mission-control',
});
}, schedule => !cronScheduleHasReadOnlyViewerTarget(schedule, server));
scheduler.start();
server.decorate('scheduler', scheduler);
// Self-evolution: idle-session watcher (CowAgent steal #3, v1). Default OFF via
// <dataDir>/self-evolution.json; when enabled, it reviews idle sessions through
// a restricted `session-reviewer` loopback turn whose only write (create_skill)
// is HELD for human approval. Skipped under test to keep unit runs hermetic
// (mirrors the ChannelManager VITEST guard below).
const idleWatcher = new IdleSessionWatcher({
dataDir: fullConfig.dataDir,
emitNotification: (event, options) => emitNotification(server, event, options),
log: { info: (msg: string) => log.info(msg), warn: (msg: string) => log.warn(msg) },
runReviewTurn: async ({ sessionId, workspaceId }) => {
const transcript = readRecentTranscript(fullConfig.dataDir, workspaceId, sessionId);
if (!transcript) return { content: NOTHING_TO_DO };
const res = await runChannelChatTurn({
port: server.localConfig.port,
sessionToken: server.agentState.wsSessionToken,
message: buildReviewInstruction(sessionId, transcript),
workspace: workspaceId,
session: `evolve-${sessionId}`,
persona: 'session-reviewer',
proposeHeld: true,
origin: 'automation',
});
return { content: res.content, ...(res.error ? { error: res.error } : {}) };
},
});
server.decorate('idleWatcher', idleWatcher);
if (!process.env.VITEST && process.env.NODE_ENV !== 'test') {
idleWatcher.start();
}
server.addHook('onClose', async () => {
idleWatcher.stop();
});
// H-10 G1: Evolution service — autonomous self-evolution daemon.
// Disabled by default; opt-in via WAGGLE_EVOLUTION_AUTO_ENABLED=1 so
// existing deployments don't start burning Anthropic credits silently.
// Even when enabled, the service only produces `proposed` runs — accept
// still happens manually via the Memory → Evolution UI.
const evolutionService = new EvolutionService(
{
traceStore,
runStore: evolutionStore,
getApiKey: () => server.vault?.get('anthropic')?.value ?? null,
getActiveBehavioralSpec: () => (server as unknown as { activeBehavioralSpec: Record<string, unknown> }).activeBehavioralSpec,
log: (level, msg) => {
if (level === 'warn') log.warn(`[evolution-service] ${msg}`);
else log.info(`[evolution-service] ${msg}`);
},
},
{
tickIntervalMs: parseInt(process.env.WAGGLE_EVOLUTION_TICK_INTERVAL_MS ?? '', 10) || undefined,
minTracesPerTarget: parseInt(process.env.WAGGLE_EVOLUTION_MIN_TRACES ?? '', 10) || undefined,
},
);
server.decorate('evolutionService', evolutionService);
if (isEvolutionAutoEnabled()) {
evolutionService.start();
log.info('[evolution-service] autonomous evolution enabled (WAGGLE_EVOLUTION_AUTO_ENABLED=1)');
}
// F2: Daily audit event cleanup (retain 90 days by default)
const auditRetentionDays = parseInt(process.env.WAGGLE_AUDIT_RETENTION_DAYS ?? '90', 10);
const auditCleanupTimer = setInterval(() => {
const deleted = cleanupAuditEvents(fullConfig.dataDir, auditRetentionDays);
if (deleted > 0) {
log.info(`[audit] Cleaned up ${deleted} events older than ${auditRetentionDays} days`);
}
}, 24 * 60 * 60 * 1000); // once per day
// PM-6: Offline manager — periodic LLM health checks
const resolveOfflineManagerEndpoint = (): string => {
if (!fullConfig.useBuiltInProxy) return fullConfig.litellmUrl;
const address = server.server.address();
return address && typeof address === 'object'
? `http://127.0.0.1:${address.port}/v1`
: fullConfig.litellmUrl;
};
const offlineManager = new OfflineManager({
dataDir: fullConfig.dataDir,
getLlmEndpoint: resolveOfflineManagerEndpoint,
getLlmApiKey: () => server.agentState?.litellmApiKey ?? '',
checkLlmReadiness: async (signal) => {
const selectedModel = server.agentState.currentModel.trim();
const selectedOllama = selectedModel.toLowerCase().startsWith('ollama/');
const unselectedOllama = !selectedModel
&& server.agentState.llmProvider.provider === 'ollama';
if (selectedOllama || unselectedOllama) {
const localModels = await listOllamaChatModelIds(signal);
return selectedOllama
? localModels.some(model => model.toLowerCase() === selectedModel.toLowerCase())
: localModels.length > 0;
}
const endpoint = resolveOfflineManagerEndpoint().replace(/\/+$/, '');
const apiKey = server.agentState.litellmApiKey;
const headers: Record<string, string> = {};
if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
const response = await fetch(`${endpoint}/health/readiness`, {
method: 'GET',
headers,
signal: AbortSignal.any([signal, AbortSignal.timeout(5_000)]),
});
if (!response.ok) return false;
if (server.agentState.llmProvider.provider !== 'litellm') return true;
// LiteLLM readiness alone only proves the router process is accepting
// traffic. Its local model catalog must also expose the selected route.
const modelsResponse = await fetch(`${endpoint}/models`, {
method: 'GET',
headers,
signal: AbortSignal.any([signal, AbortSignal.timeout(5_000)]),
});
if (!modelsResponse.ok) return false;
const modelsPayload = await modelsResponse.json() as {
data?: Array<{ id?: string }>;
};
const modelIds = (modelsPayload.data ?? [])
.map(model => model.id)
.filter((model): model is string => typeof model === 'string');
return selectedModel ? modelIds.includes(selectedModel) : modelIds.length > 0;
},
eventBus,
checkIntervalMs: 30_000,
});
if (fullConfig.startOfflineManagerOnListen !== false) {
server.addHook('onListen', async () => {
offlineManager.start();
});
}
server.addHook('preClose', async () => {
await offlineManager.stop();
});
server.decorate('offlineManager', offlineManager);
// Plugins
// CORS restricted to known Tauri/dev origins — prevents cross-origin attacks from arbitrary websites
await server.register(cors, {
origin: (origin, cb) => {
if (corsOriginAllowed(origin)) {
cb(null, true);
} else {
cb(new Error('CORS: origin not allowed'), false);
}
},
});
await server.register(websocket);
// Security middleware — headers + rate limiting + bearer auth (local server only)
const rateLimiterMaxRequests = Number.parseInt(process.env.WAGGLE_RATE_LIMIT_MAX_REQUESTS ?? '', 10);
const rateLimiterWindowMs = Number.parseInt(process.env.WAGGLE_RATE_LIMIT_WINDOW_MS ?? '', 10);
const rateLimiterConfig = {
...(Number.isFinite(rateLimiterMaxRequests) && rateLimiterMaxRequests > 0
? { maxRequests: rateLimiterMaxRequests }
: {}),
...(Number.isFinite(rateLimiterWindowMs) && rateLimiterWindowMs > 0
? { windowMs: rateLimiterWindowMs }
: {}),
};
await server.register(securityMiddleware, {
sessionToken: server.agentState.wsSessionToken,
authenticateBrowserCompanionToken: (token) => browserCompanionCredentialMatches(
token,
server.agentState.browserCompanionCredentialHash,
),
authenticateRunToken: (token) => {
const run = agentRunRegistry.authenticateCredential(token);
if (!run) return false;
return { runId: run.id, model: run.executor.model };
},
rateLimiter: Object.keys(rateLimiterConfig).length > 0 ? rateLimiterConfig : undefined,
});
// D1: session-token bootstrap. Managed desktop launches require a random
// per-launch credential delivered only through Tauri IPC. An ordinary browser
// can forge a tauri.localhost Origin, so Origin alone is not an application
// identity. Browser-only mode has no IPC channel and is instead bound to the
// exact loopback request authority (host + port).
server.get('/api/auth/session-token', async (request, reply) => {
if (!isLoopbackBind()) {
return reply.code(403).send({
error: 'Session bootstrap is available only on a loopback-bound sidecar.',
code: 'SESSION_BOOTSTRAP_LOOPBACK_ONLY',
});
}
if (managedDesktopBootstrap) {
if (!desktopBootstrapMatches(
request.headers['x-waggle-desktop-bootstrap'],
desktopBootstrapToken,
)) {
return reply.code(403).send({
error: 'Desktop session bootstrap requires the owned launch credential.',
code: 'DESKTOP_BOOTSTRAP_REQUIRED',
});
}
} else if (!browserBootstrapAuthorityAllowed(request)) {
return reply.code(403).send({
error: 'Session bootstrap origin does not match the local service authority.',
code: 'SESSION_BOOTSTRAP_ORIGIN_MISMATCH',
});
}
reply.header('Cache-Control', 'no-store');
return { token: server.agentState.wsSessionToken };
});
// P5 (PDF 2026-04-17): minimal debug-log viewer for support attachments.
// Returns health + last 500 audit events + recent cost entries as JSON.
server.get('/api/debug/logs', async (request, reply) => {
// R2-006: same-origin gate — this endpoint exposes audit history and is
// recon material; never serve it cross-origin (defense in depth behind
// the loopback bind).
if (!isLocalRequest(request)) {
return reply.code(403).send({ error: 'Forbidden: external origin' });
}
const payload: Record<string, unknown> = {
timestamp: new Date().toISOString(),
version: '0.2.0',
platform: process.platform,
};
try { payload.health = await server.inject({ method: 'GET', url: '/health' }).then(r => JSON.parse(r.payload)); } catch { /* non-blocking */ }
try {
const raw = (server.auditStore as unknown as { db?: { prepare: (sql: string) => { all: () => unknown[] } } })?.db;
if (raw) {
// R2-006: expose only a coarse, non-recon column subset (no capability
// names/versions/sources, risk_level, approval_class, initiator or detail)
// and cap the rows — the support bundle needs activity shape, not an inventory.
payload.auditRecent = raw.prepare('SELECT timestamp, action, capability_type FROM install_audit ORDER BY timestamp DESC LIMIT 50').all();
}
} catch { /* non-blocking */ }
// R2-006: vault key NAMES dropped — even names are recon material and the
// support bundle does not need them.
reply.header('Content-Type', 'application/json; charset=utf-8');
reply.header('Content-Disposition', `attachment; filename="waggle-logs-${Date.now()}.json"`);
return payload;
});
// Routes
await server.register(workspaceRoutes);
await server.register(chatRoutes);
await server.register(memoryRoutes);
await server.register(memoryCenterRoutes);
await server.register(settingsRoutes);
await server.register(embeddingRoutes);
await server.register(sessionRoutes);
await server.register(knowledgeRoutes);
await server.register(litellmRoutes);
await server.register(ingestRoutes);
await server.register(mindRoutes);
await server.register(agentRoutes);
await server.register(skillRoutes);
// UX-Refactor Phase 3: /api/skills/:id aliases (S06/S19) — delegates into
// skillRoutes handlers, so it registers right after them.
await server.register(skillsAliasRoutes);
await server.register(skillsHygieneRoutes);
await server.register(skillsAuditRoutes);
await server.register(approvalRoutes);
await server.register(anthropicProxyRoutes);
await server.register(teamRoutes);
await server.register(taskRoutes);
await server.register(capabilitiesRoutes);
await server.register(toolsRoutes);
await server.register(externalToolRunRoutes);
await server.register(routeProposalRoutes);
await server.register(waggleDanceRoutes);
await server.register(commandRoutes);
// UX-Refactor Phase 1: Home Cockpit (S01) + Command Center (S00/S03) surfaces.
// commandCenterRoutes registers the singular /api/command/* aliases (B4) — it
// is distinct from the plural commandRoutes (/api/commands/execute) above.
await server.register(homeRoutes);
await server.register(onboardingRoutes);
await server.register(commandCenterRoutes);
await server.register(cronRoutes);
// UX-Refactor Phase 3: Agent entity (S09/S18, B3 agents.json) + the
// /api/automations/* PRD-vocabulary alias over cron (S11/S20, B4).
// agentEntityRoutes is distinct from agentRoutes (/api/agent/* + /api/agents/
// active) and agentGroupRoutes; the static /api/agents/active keeps precedence
// over the new /:id param route (find-my-way prefers static segments).
await server.register(agentEntityRoutes);
await server.register(automationRoutes);
await server.register(notificationRoutes);
await server.register(marketplaceDevRoutes);
await server.register(marketplaceRoutes);
await server.register(createCapabilityProposalRoutes(
capabilityProposalStore,
(identity) => installMarketplaceApprovalIdentity(server, identity),
));
await server.register(agentSearchRoutes);
await server.register(connectorRoutes);
// UX-Refactor Phase 4 (Extend layer): MCP Hub (S08) + the marketplace
// bare-path alias / shared install-audit read (S21, C18). extendRoutes
// delegates onto marketplaceRoutes via inject — register after it.
await server.register(mcpRoutes);
await server.register(extendRoutes);
await server.register(fleetRoutes);
await server.register(importRoutes);
await server.register(vaultRoutes);
await server.register(personaRoutes);
await server.register(feedbackRoutes);
await server.register(workspaceTemplateRoutes);
await server.register(evolutionRoutes);
await server.register(exportRoutes);
await server.register(dataEraseRoutes);
await server.register(costRoutes);
await server.register(backupRoutes);
await server.register(offlineRoutes);
await server.register(weaverRoutes);
await server.register(eventRoutes);
await server.register(workflowRoutes);
await server.register(pinRoutes);
await server.register(documentRoutes);
await server.register(artifactRoutes);
await server.register(fileRoutes);
await server.register(waggleSignalRoutes);
await server.register(providerRoutes);
await server.register(profileRoutes);
await server.register(oauthRoutes);
await server.register(browseRoutes);
await server.register(browserExtRoutes);
await server.register(telegramRoutes);
// IM channel adapters (Slack/Telegram/WhatsApp/Discord) — see
// docs/plans/CHANNELS-ARC-2026-07-09.md. Manager owns adapter lifecycle;
// adapters run agent turns through loopback POST /api/chat.
{
const channelManager = new ChannelManager({
dataDir: server.localConfig.dataDir,
port: server.localConfig.port,
sessionToken: server.agentState.wsSessionToken,
vault: {
get: (key: string) => server.vault?.get(key) ?? null,
has: (key: string) => server.vault?.has(key) ?? false,
set: (key: string, value: string, metadata?: Record<string, unknown>) => {
if (!server.vault) throw new Error('Vault is unavailable');
server.vault.set(key, value, metadata);
},
delete: (key: string) => server.vault?.delete(key) ?? false,
},
log: {
info: (msg: string) => server.log.info(msg),
warn: (msg: string) => server.log.warn(msg),
},
listWorkspaces: () => wsManager.list().map(w => ({ id: w.id, name: w.name })),
onAudit: (event) => emitAuditEvent(server, {
workspaceId: 'default',
eventType: event.type,
input: JSON.stringify({ platform: event.platform, detail: event.detail ?? '' }),
}),
});
server.decorate('channelManager', channelManager);
// Auto-start enabled channels once the server is up; skip under test to
// keep unit runs hermetic (mirrors the teams-server VITEST guard below).
if (!process.env.VITEST && process.env.NODE_ENV !== 'test') {
server.addHook('onReady', async () => {
await channelManager.startEnabled();
});
}
server.addHook('onClose', async () => {
await channelManager.stopAll();
});
}
await server.register(channelRoutes);
await server.register(dreamRoutes);
await server.register(telemetryRoutes);
await server.register(agentGroupRoutes);
await server.register(localJobRoutes);
await server.register(harvestRoutes);
await server.register(wikiRoutes);
await server.register(identityRoutes);
await server.register(agentRunRoutes);
await server.register(agentRunsRoutes);
await server.register(localInferenceRoutes);
await server.register(complianceRoutes);
// ── Static file serving for web mode ──────────────────────────
// When WAGGLE_FRONTEND_DIR is set, serve the React frontend as static files.
// Otherwise probe likely build outputs. The canonical build (per root
// package.json `build` script) is `<root>/dist`, which apps/web/vite
// writes to. `app/dist` is kept as a fallback for legacy Tauri-shell
// builds but is no longer the primary source — if both exist, root dist wins.
const frontendDir = process.env.WAGGLE_FRONTEND_DIR
?? [
// Root `dist/` — primary build target from `npm run build`
path.resolve(process.cwd(), 'dist'), // from monorepo root
path.resolve(process.cwd(), '..', '..', 'dist'), // from packages/server/
path.resolve(process.cwd(), '..', 'dist'), // from packages/
...(typeof process.argv[1] === 'string' ? [path.resolve(path.dirname(process.argv[1]), '..', '..', '..', '..', 'dist')] : []),
// Legacy `app/dist/` — Tauri shell build, kept as fallback
path.resolve(process.cwd(), 'app', 'dist'), // from monorepo root
path.resolve(process.cwd(), '..', '..', 'app', 'dist'), // from packages/server/
path.resolve(process.cwd(), '..', 'app', 'dist'), // from packages/
...(typeof process.argv[1] === 'string' ? [path.resolve(path.dirname(process.argv[1]), '..', '..', '..', '..', 'app', 'dist')] : []),
].find(d => fs.existsSync(path.join(d, 'index.html'))) ?? path.resolve(process.cwd(), 'dist');
if (fs.existsSync(frontendDir) && fs.existsSync(path.join(frontendDir, 'index.html'))) {
await server.register(fastifyStatic, {
root: frontendDir,
prefix: '/',
wildcard: false,
});
// SPA fallback: serve index.html for all non-API, non-static, non-asset routes
server.setNotFoundHandler((request, reply) => {
// Don't intercept API routes, WebSocket upgrades, or static assets
if (request.url.startsWith('/api/') || request.url.startsWith('/v1/') ||
request.url.startsWith('/assets/') ||
request.url === '/health' || request.url === '/ws') {
reply.code(404).send({ error: 'Not found' });
return;
}
reply.sendFile('index.html', frontendDir);
});
}
// WebSocket endpoint — event bus relay to frontend
// 11A-6: Require session token for WebSocket authentication
// 11A-8: Per-connection listener tracking (don't kill other clients on disconnect)
server.get('/ws', { websocket: true }, (socket, request) => {
// 11A-6: Validate session token from query param
const url = new URL(request.url, 'http://localhost');
const token = url.searchParams.get('token');
if (token !== server.agentState.wsSessionToken) {
socket.close(4001, 'Unauthorized: invalid session token');
return;
}
// Per-connection listener references for clean removal on disconnect
const listenerMap = new Map<string, (...args: unknown[]) => void>();
// Forward approval events and agent events to the WebSocket client
const eventTypes = ['approval_required', 'step', 'tool', 'done', 'error', 'presence_update', 'notification'] as const;
for (const evt of eventTypes) {
const handler = (data: unknown) => {
try {
socket.send(JSON.stringify({ event: evt, data }));
} catch {
// Client disconnected
}
};
listenerMap.set(evt, handler);
eventBus.on(evt, handler);
}
socket.on('message', (raw: Buffer) => {
try {
const msg = JSON.parse(raw.toString()) as { type: string; requestId?: string; reason?: string };
if (msg.type === 'approve' && msg.requestId) {
const pending = server.agentState.pendingApprovals.get(msg.requestId);
if (pending) {
server.agentState.pendingApprovals.delete(msg.requestId);
pending.resolve(true);
}
} else if (msg.type === 'deny' && msg.requestId) {
const pending = server.agentState.pendingApprovals.get(msg.requestId);
if (pending) {
server.agentState.pendingApprovals.delete(msg.requestId);
pending.resolve(false);
}
}
} catch {
// Ignore malformed messages
}
});
socket.on('close', () => {
// Remove only THIS connection's listeners, not all clients'
for (const [evt, handler] of listenerMap) {
eventBus.removeListener(evt, handler);
}
listenerMap.clear();
});
});
// P0-3: Cached API key validation — verify key actually works, not just exists
let keyValidationCache: { valid: boolean; checkedAt: number; keyHash: string } | null = null;
let keyValidationInFlight: Promise<void> | null = null;
const KEY_VALIDATION_TTL = 30 * 1000; // 30 seconds — short so vault updates are picked up quickly
function hashKey(key: string): string {
// Simple hash for cache invalidation — not cryptographic
let h = 0;
for (let i = 0; i < key.length; i++) {
h = ((h << 5) - h + key.charCodeAt(i)) | 0;
}
return String(h);
}
function getAnthropicApiKey(): string {
const vaultKey = server.vault?.get('anthropic')?.value;
return vaultKey || process.env.ANTHROPIC_API_KEY || '';
}
function freshAnthropicValidation(): boolean | null {
const apiKey = getAnthropicApiKey();
if (!apiKey) return false;
const currentHash = hashKey(apiKey);
if (
keyValidationCache &&
keyValidationCache.keyHash === currentHash &&
Date.now() - keyValidationCache.checkedAt < KEY_VALIDATION_TTL
) {
return keyValidationCache.valid;
}
return null;
}
function markAnthropicProxyDegraded(detail = 'Built-in Anthropic proxy (API key invalid or expired — update in Settings > API Keys)'): void {
server.agentState.llmProvider.health = 'degraded';
server.agentState.llmProvider.detail = detail;
}
async function validateAnthropicKey(): Promise<boolean> {
// Read key from vault first, fall back to env var
const apiKey = getAnthropicApiKey();
if (!apiKey) return false;
const currentHash = hashKey(apiKey);
// Return cached result if fresh AND key hasn't changed
if (
keyValidationCache &&
keyValidationCache.keyHash === currentHash &&
Date.now() - keyValidationCache.checkedAt < KEY_VALIDATION_TTL
) {
return keyValidationCache.valid;
}
try {
// Lightweight API call to verify key works
const res = await fetch('https://api.anthropic.com/v1/messages', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'x-api-key': apiKey,
'anthropic-version': '2023-06-01',
},
body: JSON.stringify({
model: 'claude-haiku-4-5-20251001',
max_tokens: 1,
messages: [{ role: 'user', content: 'hi' }],
}),
signal: AbortSignal.timeout(5000),
});
// 200 = valid, 401 = invalid/expired, 400 = valid key but bad request (still means key works)
const valid = res.status !== 401 && res.status !== 403;
keyValidationCache = { valid, checkedAt: Date.now(), keyHash: currentHash };
return valid;
} catch {
// Network error — don't cache failure, key might be fine
return keyValidationCache?.valid ?? true;
}
}
function validateAnthropicKeyInBackground(): void {
if (keyValidationInFlight) return;
keyValidationInFlight = validateAnthropicKey()
.then((valid) => {
if (!valid && server.agentState.llmProvider.provider === 'anthropic-proxy') {
markAnthropicProxyDegraded();
}
})
.finally(() => {
keyValidationInFlight = null;
});
keyValidationInFlight.catch(() => { /* fire-and-forget guard */ });
}
// Expose cache invalidation for settings route to call after key update
server._invalidateKeyValidationCache = () => {
keyValidationCache = null;
// If currently degraded due to bad key, reset to healthy for re-validation
if (server.agentState.llmProvider.health === 'degraded') {
server.agentState.llmProvider.health = 'healthy';
server.agentState.llmProvider.detail = 're-validating after key change';
}
};
// IMP-15: API docs — auto-generated from Fastify route registry
server.get('/api/docs', async () => {
const routes: Array<{ method: string; url: string; prefix: string }> = [];
// Fastify exposes registered routes via the internal routing tree, which is
// not part of the public typings — read it through an `unknown[]` and narrow.
const allRoutes: unknown[] = (server as { routes?: unknown[] }).routes ?? [];
// Iterate printRoutes() style — Fastify 4.x stores routes differently
// Use server.printRoutes() as a fallback reference
try {
// Fastify stores routes in server[Symbol.for('registered-routes')] or similar
// Best approach: iterate after ready using routesByMethod
for (const route of allRoutes) {
if (route && typeof route === 'object' && 'url' in route && 'method' in route) {
const r = route as { url: string; method: string | string[]; prefix?: string };
const methods = Array.isArray(r.method) ? r.method : [r.method];
for (const m of methods) {
routes.push({ method: m, url: r.url, prefix: r.prefix ?? '' });
}
}
}
} catch { /* fallback to empty */ }
// If routes array is empty (Fastify internals differ), provide static list
if (routes.length === 0) {
return {
openapi: '3.0.0',
info: { title: 'Waggle API', version: '1.0.0', description: 'Workspace-native AI agent platform' },
note: 'Dynamic route listing unavailable. Use GET /health for status.',
categories: {
chat: ['POST /api/chat'],
workspaces: ['GET /api/workspaces', 'POST /api/workspaces', 'GET /api/workspaces/:id', 'PUT /api/workspaces/:id', 'DELETE /api/workspaces/:id', 'GET /api/workspaces/:id/cost', 'GET /api/workspaces/:id/context', 'GET /api/workspaces/:id/files', 'GET /api/workspaces/:id/storage', 'GET /api/workspaces/:id/storage/files', 'GET /api/workspaces/:id/storage/read', 'POST /api/workspaces/:id/storage/write', 'DELETE /api/workspaces/:id/storage/delete'],
memory: ['GET /api/memory/search', 'GET /api/memory/frames', 'POST /api/memory/frames', 'DELETE /api/memory/frames/:id', 'GET /api/memory/stats', 'GET /api/memory/graph'],
sessions: ['GET /api/workspaces/:workspaceId/sessions', 'POST /api/workspaces/:workspaceId/sessions', 'PATCH /api/sessions/:sessionId', 'DELETE /api/sessions/:sessionId', 'GET /api/sessions/:sessionId/summary'],
teams: ['GET /api/teams', 'POST /api/teams', 'GET /api/teams/:id', 'PUT /api/teams/:id', 'DELETE /api/teams/:id', 'POST /api/teams/:id/members', 'PUT /api/teams/:id/members/:userId', 'DELETE /api/teams/:id/members/:userId', 'GET /api/teams/:id/activity'],
events: ['GET /api/events', 'GET /api/events/stats', 'GET /api/events/stream'],
settings: ['GET /api/settings', 'PUT /api/settings', 'PATCH /api/settings', 'POST /api/settings/test-key', 'POST /api/settings/probe-provider'],
vault: ['GET /api/vault', 'POST /api/vault', 'DELETE /api/vault/:name'],
fleet: ['GET /api/fleet', 'POST /api/fleet/:workspaceId/pause', 'POST /api/fleet/:workspaceId/resume', 'POST /api/fleet/:workspaceId/kill'],
cost: ['GET /api/cost/summary', 'GET /api/cost/by-workspace', 'GET /api/costs'],
agent: ['GET /api/agent/status', 'GET /api/agent/model', 'GET /api/agent/cost'],
marketplace: ['GET /api/marketplace/search', 'GET /api/marketplace/packs', 'POST /api/marketplace/install', 'POST /api/marketplace/uninstall'],
connectors: ['GET /api/connectors', 'POST /api/connectors/:id/connect', 'POST /api/connectors/:id/disconnect'],
other: ['GET /health', 'POST /api/export', 'POST /api/backup', 'POST /api/restore', 'GET /api/cron', 'POST /api/ingest', 'GET /api/personas', 'GET /api/workspace-templates'],
},
};
}
// Dynamic route listing
const grouped: Record<string, string[]> = {};
for (const r of routes) {
if (!r.url.startsWith('/api/') && r.url !== '/health') continue;
const category = r.url.split('/')[2] ?? 'other';
if (!grouped[category]) grouped[category] = [];
grouped[category].push(`${r.method} ${r.url}`);
}
return {
openapi: '3.0.0',
info: { title: 'Waggle API', version: '1.0.0', description: 'Workspace-native AI agent platform' },
endpointCount: routes.filter(r => r.url.startsWith('/api/')).length,
categories: grouped,
};
});
// Embedding provider status + reprobe endpoints. (The set/write side —
// POST /api/embedding/provider — lives in routes/embedding.ts.)
server.get('/api/embedding/status', async () => {
// Enriched shape: live status + persisted `configuredProvider` + `envOverride`.
return buildEmbeddingStatusPayload(server);
});
server.post('/api/embedding/reprobe', async () => {
// Re-read API keys from Vault (user may have just added one)
try {
const voyageEntry = vault.get('voyage-api-key');
if (voyageEntry?.value) embeddingConfig.voyage = { apiKey: voyageEntry.value };
} catch { /* skip */ }
try {
const openaiEntry = vault.get('openai');
if (openaiEntry?.value) embeddingConfig.openai = { apiKey: openaiEntry.value };
} catch { /* skip */ }
return embeddingProvider.reprobe();
});
// Health check — truthful, not optimistic
server.get('/health', async () => {
const llm = { ...server.agentState.llmProvider };
const listeningAddress = server.server.address();
const servicePort = typeof listeningAddress === 'object' && listeningAddress
? listeningAddress.port
: server.localConfig.port;
// P0-3: If provider is anthropic-proxy and claims healthy, validate the key actually works
if (
llm.provider === 'anthropic-proxy'
&& llm.health === 'healthy'
&& llm.detail.startsWith('Built-in Anthropic proxy')
) {
const keyValid = freshAnthropicValidation();
if (keyValid === false) {
llm.health = 'degraded';
llm.detail = 'Built-in Anthropic proxy (API key invalid or expired — update in Settings > API Keys)';
markAnthropicProxyDegraded(llm.detail);
} else if (keyValid === null) {
validateAnthropicKeyInBackground();
}
}
const dbHealthy = (() => {
try {
multiMind.personal.getDatabase().prepare('SELECT 1').get();
return true;
} catch {
return false;
}
})();
// Startup may resolve a provider after OfflineManager's initial probe.
// Once a later completion-readiness probe runs, it becomes authoritative.
const offlineState = offlineManager.state;
const providerCheckedAt = Date.parse(llm.checkedAt);
const readinessCheckedAt = Date.parse(offlineManager.lastCheck);
const providerStatusIsNewer = Number.isFinite(providerCheckedAt)
&& providerCheckedAt > readinessCheckedAt;
const llmReachable = providerStatusIsNewer
? llm.health === 'healthy'
: !offlineState.offline;
const effectiveOfflineState = {
...offlineState,
offline: !llmReachable,
since: llmReachable ? null : offlineState.since,
};
const overallStatus = llmReachable && llm.health === 'healthy' && dbHealthy
? 'ok'
: llm.health === 'unavailable' || !dbHealthy
? 'unavailable'
: 'degraded';
// Memory stats — frame count + mind file size
const memoryStats = (() => {
try {
const db = multiMind.personal.getDatabase();
const row = db.prepare('SELECT COUNT(*) as cnt FROM memory_frames').get() as { cnt: number } | undefined;
const frameCount = row?.cnt ?? 0;
// Get mind file size from the known personal mind path
let mindSizeBytes = 0;
try {
const stat = fs.statSync(personalPath);
mindSizeBytes = stat.size;
} catch { /* file may not exist yet */ }
// Embedding coverage — frames with vectors vs total frames
let embeddingCoverage = 0;
try {
const totalRow = db.prepare('SELECT COUNT(*) as cnt FROM memory_frames').get() as { cnt: number };
const vecRow = db.prepare('SELECT COUNT(*) as cnt FROM memory_frames_vec').get() as { cnt: number } | undefined;
const vecCount = vecRow?.cnt ?? 0;
if (totalRow.cnt > 0) {
embeddingCoverage = Math.round((vecCount / totalRow.cnt) * 100);
}
} catch { /* vec table may not exist */ }
const embeddingProviderStatus = server.embeddingProvider?.getStatus?.() ?? null;
return { frameCount, mindSizeBytes, embeddingCoverage, embeddingProvider: embeddingProviderStatus };
} catch {
return { frameCount: 0, mindSizeBytes: 0, embeddingCoverage: 0, embeddingProvider: null };
}
})();
// Service health — watchdog and notification SSE status
const serviceHealth = {
watchdogRunning: scheduler.isRunning(),
notificationSSEActive: eventBus.listenerCount('notification') > 0,
};
return {
status: overallStatus,
mode: 'local',
instanceId: server.localConfig.instanceId ?? null,
port: servicePort,
timestamp: new Date().toISOString(),
llm: {
provider: llm.provider,
health: llm.health,
detail: llm.detail,
checkedAt: llm.checkedAt,
reachable: llmReachable,
lastCheck: new Date().toISOString(),
},
database: { healthy: dbHealthy },
memoryStats,
serviceHealth,
defaultModel: server.agentState.currentModel,
offline: effectiveOfflineState,
// R1-001: wsToken intentionally NOT returned — /health is unauthenticated
// and the token authenticates every other route. Localhost clients are
// trusted by security-middleware and never needed it.
};
});
// Cleanup on close
server.addHook('onClose', async () => {
// Stop cron scheduler
localJobStore.close();
agentRunRegistry.close();
stopMarketplaceBackgroundSync();
scheduler.stop();
evolutionService.stop();
await offlineManager.stop();
clearInterval(auditCleanupTimer);
// Stop MCP servers
await mcpRuntime.stopAll().catch(() => {});
// Stop weaver timers
for (const t of weaverTimers) clearInterval(t);
for (const [, ww] of workspaceWeavers) {
for (const t of ww.timers) clearInterval(t);
}
workspaceWeavers.clear();
// Close all workspace sessions (new concurrent model)
sessionManager.closeAll();
// Let the active bounded pass finish before closing any borrowed mind.
await vectorEnrichmentService.stop();
// Close all cached workspace minds
mindCache.closeAll();
multiMind.close();
// Close audit DB, teams DB, and telemetry
closeAuditDb();
closeTeamsDb();
try { telemetry.close(); } catch { /* already closed */ }
// Close marketplace DB
if (marketplaceDb) {
try { marketplaceDb.close(); } catch { /* already closed */ }
}
});
vectorEnrichmentService.start();
// ── Start Teams server if PostgreSQL is configured (TEAMS tier) ──
// Skip in test environment to avoid port conflicts and addHook-after-listen errors
if (process.env.DATABASE_URL && !process.env.VITEST && process.env.NODE_ENV !== 'test') {
// DAY0V-03 / F-02: cloud-mode detected (DATABASE_URL set) — require CLERK_SECRET_KEY.
// The Teams server registers wsGateway, which itself hard-fails in NODE_ENV=production
// when the key is absent (see packages/server/src/ws/gateway.ts DAY0V-01 fix). We surface
// the misconfiguration here too so the operator sees a single clear log line instead of
// a buildServer rejection further down.
if (!process.env.CLERK_SECRET_KEY) {
log.error(
'[teams-server] CLERK_SECRET_KEY missing while DATABASE_URL is set. Cloud/Teams ' +
'deployment requires both. Skipping Teams server startup — set CLERK_SECRET_KEY ' +
'and restart, or unset DATABASE_URL to run desktop-only.',
);
} else {
const teamsPort = parseInt(process.env.TEAMS_SERVER_PORT ?? '3101', 10);
import('../index.js').then(({ buildServer }) => {
buildServer().then(teamsServer => {
teamsServer.listen({ port: teamsPort, host: '127.0.0.1' }, (err) => {
if (err) {
log.info(`[teams-server] Failed to start: ${err.message}`);
} else {
log.info(`[teams-server] Running at http://127.0.0.1:${teamsPort}`);
}
});
server.addHook('onClose', async () => { await teamsServer.close(); });
}).catch(err => log.info(`[teams-server] Build failed: ${(err as Error).message}`));
}).catch(() => { /* Teams server optional — non-blocking */ });
}
}
return server;
}