@agentuity/runtime 1.0.24 → 1.0.25

package/src/dev-patches/gateway.ts

@@ -0,0 +1,70 @@
+/**
+ * Runtime LLM Gateway patches for dev mode.
+ *
+ * Replaces the build-time patches from cli/src/cmd/build/patch/llm.ts.
+ * Sets environment variables to route LLM SDK calls through the Agentuity AI Gateway
+ * when the user hasn't provided their own API keys.
+ */
+
+interface GatewayConfig {
+	apiKeyEnv: string;
+	baseUrlEnv: string;
+	provider: string;
+}
+
+const GATEWAY_CONFIGS: GatewayConfig[] = [
+	{ apiKeyEnv: 'ANTHROPIC_API_KEY', baseUrlEnv: 'ANTHROPIC_BASE_URL', provider: 'anthropic' },
+	{ apiKeyEnv: 'GROQ_API_KEY', baseUrlEnv: 'GROQ_BASE_URL', provider: 'groq' },
+	{ apiKeyEnv: 'OPENAI_API_KEY', baseUrlEnv: 'OPENAI_BASE_URL', provider: 'openai' },
+];
+
+function warnMissingKey(envKey: string): void {
+	const isDev =
+		process.env.AGENTUITY_ENVIRONMENT === 'development' || process.env.NODE_ENV !== 'production';
+	if (isDev) {
+		console.error('[ERROR] No credentials found for this AI provider. To fix this, either:');
+		console.error(
+			'  1. Login to Agentuity Cloud (agentuity auth login) to use the AI Gateway (recommended)'
+		);
+		console.error(`  2. Set ${envKey} in your .env file to use the provider directly`);
+	} else {
+		console.error(`[ERROR] The environment variable ${envKey} is required. Either:`);
+		console.error(
+			'  1. Use Agentuity Cloud AI Gateway by ensuring AGENTUITY_SDK_KEY is configured'
+		);
+		console.error(`  2. Set ${envKey} using "agentuity env set ${envKey}" and redeploy`);
+	}
+}
+
+/**
+ * Set environment variables to route LLM calls through the AI Gateway.
+ *
+ * For each provider, if the user hasn't set their own API key (or it equals
+ * the SDK key), we redirect to the gateway. This matches the behavior of
+ * the build-time patches in patch/llm.ts.
+ */
+export function applyGatewayPatches(): void {
+	const sdkKey = process.env.AGENTUITY_SDK_KEY;
+	const gatewayUrl =
+		process.env.AGENTUITY_AIGATEWAY_URL ||
+		process.env.AGENTUITY_TRANSPORT_URL ||
+		(sdkKey ? 'https://agentuity.ai' : '');
+
+	for (const config of GATEWAY_CONFIGS) {
+		const currentKey = process.env[config.apiKeyEnv];
+
+		// If the user provided their own key (and it's not the SDK key), leave it alone
+		if (currentKey && currentKey !== sdkKey) {
+			continue;
+		}
+
+		// Route through gateway if we have both URL and SDK key
+		if (gatewayUrl && sdkKey) {
+			process.env[config.apiKeyEnv] = sdkKey;
+			process.env[config.baseUrlEnv] = `${gatewayUrl}/gateway/${config.provider}`;
+			console.debug(`Enabled Agentuity AI Gateway for ${config.provider}`);
+		} else if (!currentKey) {
+			warnMissingKey(config.apiKeyEnv);
+		}
+	}
+}

package/src/dev-patches/index.ts

@@ -0,0 +1,37 @@
+/**
+ * Runtime dev patches — replaces build-time Bun.build patches for dev mode.
+ *
+ * When --experimental-no-bundle is used, the generated entry file (src/generated/app.ts)
+ * is run directly by Bun without bundling. These runtime patches apply the same
+ * monkey-patches that would normally be injected by the Bun.build plugin during bundling.
+ *
+ * Three categories of patches:
+ * 1. Gateway: Set env vars to route LLM calls through Agentuity AI Gateway
+ * 2. AI SDK: Wrap Vercel AI SDK functions with telemetry + gateway config
+ * 3. OTel LLM: Wrap LLM SDK .create() methods with OpenTelemetry spans
+ */
+
+import { applyGatewayPatches } from './gateway';
+import { applyAISDKCorePatches, applyAISDKProviderPatches } from './aisdk';
+import { applyOtelLLMPatches } from './otel-llm';
+
+/**
+ * Apply all runtime dev patches.
+ *
+ * Must be called:
+ * - AFTER bootstrapRuntimeEnv() (so env vars like AGENTUITY_SDK_KEY are loaded)
+ * - BEFORE any user code imports LLM SDKs
+ */
+export async function applyDevPatches(): Promise<void> {
+	// 1. Set gateway env vars first (other patches may read them)
+	applyGatewayPatches();
+
+	// 2. Patch AI SDK core functions (telemetry injection)
+	await applyAISDKCorePatches();
+
+	// 3. Patch AI SDK provider factories (gateway routing)
+	await applyAISDKProviderPatches();
+
+	// 4. Patch LLM SDK prototypes with OTel spans
+	await applyOtelLLMPatches();
+}

package/src/dev-patches/otel-llm.ts

@@ -0,0 +1,408 @@
+/**
+ * Runtime OpenTelemetry LLM instrumentation patches for dev mode.
+ *
+ * Replaces the build-time patches from cli/src/cmd/build/patch/otel-llm.ts.
+ * Wraps LLM SDK methods (OpenAI, Anthropic, Groq) with OTel spans to capture
+ * model, tokens, latency, and streaming support.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { SpanKind, SpanStatusCode, trace } from '@opentelemetry/api';
+import type { Span } from '@opentelemetry/api';
+
+const ATTR_GEN_AI_SYSTEM = 'gen_ai.system';
+const ATTR_GEN_AI_REQUEST_MODEL = 'gen_ai.request.model';
+const ATTR_GEN_AI_REQUEST_MAX_TOKENS = 'gen_ai.request.max_tokens';
+const ATTR_GEN_AI_REQUEST_TEMPERATURE = 'gen_ai.request.temperature';
+const ATTR_GEN_AI_REQUEST_TOP_P = 'gen_ai.request.top_p';
+const ATTR_GEN_AI_REQUEST_FREQUENCY_PENALTY = 'gen_ai.request.frequency_penalty';
+const ATTR_GEN_AI_REQUEST_PRESENCE_PENALTY = 'gen_ai.request.presence_penalty';
+const ATTR_GEN_AI_RESPONSE_MODEL = 'gen_ai.response.model';
+const ATTR_GEN_AI_RESPONSE_ID = 'gen_ai.response.id';
+const ATTR_GEN_AI_RESPONSE_FINISH_REASONS = 'gen_ai.response.finish_reasons';
+const ATTR_GEN_AI_USAGE_INPUT_TOKENS = 'gen_ai.usage.input_tokens';
+const ATTR_GEN_AI_USAGE_OUTPUT_TOKENS = 'gen_ai.usage.output_tokens';
+const ATTR_GEN_AI_OPERATION_NAME = 'gen_ai.operation.name';
+const ATTR_GEN_AI_REQUEST_MESSAGES = 'gen_ai.request.messages';
+const ATTR_GEN_AI_RESPONSE_TEXT = 'gen_ai.response.text';
+
+const otelTracer = trace.getTracer('@agentuity/otel-llm', '1.0.0');
+
+interface OtelPatchConfig {
+	provider: string;
+	inputTokensField: string;
+	outputTokensField: string;
+	responseIdField: string;
+	finishReasonExtractor: (response: any) => string | undefined;
+	responseContentExtractor: (response: any) => string | undefined;
+	requestMessagesField: string;
+	streamDeltaContentExtractor: (chunk: any) => string | undefined;
+	streamFinishReasonExtractor: (chunk: any) => string | undefined;
+	streamUsageExtractor: (chunk: any) => any;
+}
+
+function wrapAsyncIterator(
+	iterator: AsyncIterator<any>,
+	span: Span,
+	config: OtelPatchConfig
+): AsyncIterableIterator<any> {
+	const contentChunks: string[] = [];
+	let finishReason: string | null = null;
+	let usage: any = null;
+	let model: string | null = null;
+	let responseId: string | null = null;
+
+	return {
+		[Symbol.asyncIterator]() {
+			return this;
+		},
+		async next() {
+			try {
+				const result = await iterator.next();
+				if (result.done) {
+					// Stream complete — finalize span
+					if (contentChunks.length > 0) {
+						span.setAttribute(ATTR_GEN_AI_RESPONSE_TEXT, contentChunks.join(''));
+					}
+					if (finishReason) {
+						span.setAttribute(
+							ATTR_GEN_AI_RESPONSE_FINISH_REASONS,
+							JSON.stringify([finishReason])
+						);
+					}
+					if (model) {
+						span.setAttribute(ATTR_GEN_AI_RESPONSE_MODEL, model);
+					}
+					if (responseId) {
+						span.setAttribute(ATTR_GEN_AI_RESPONSE_ID, responseId);
+					}
+					if (usage) {
+						if (usage[config.inputTokensField] !== undefined) {
+							span.setAttribute(
+								ATTR_GEN_AI_USAGE_INPUT_TOKENS,
+								usage[config.inputTokensField]
+							);
+						}
+						if (usage[config.outputTokensField] !== undefined) {
+							span.setAttribute(
+								ATTR_GEN_AI_USAGE_OUTPUT_TOKENS,
+								usage[config.outputTokensField]
+							);
+						}
+					}
+					span.setStatus({ code: SpanStatusCode.OK });
+					span.end();
+					return result;
+				}
+
+				const chunk = result.value;
+
+				if (chunk.model && !model) model = chunk.model;
+				if (chunk.id && !responseId) responseId = chunk.id;
+
+				const deltaContent = config.streamDeltaContentExtractor(chunk);
+				if (deltaContent) contentChunks.push(deltaContent);
+
+				const chunkFinishReason = config.streamFinishReasonExtractor(chunk);
+				if (chunkFinishReason) finishReason = chunkFinishReason;
+
+				const chunkUsage = config.streamUsageExtractor(chunk);
+				if (chunkUsage) usage = chunkUsage;
+
+				return result;
+			} catch (error: any) {
+				span.setStatus({ code: SpanStatusCode.ERROR, message: error?.message });
+				span.recordException(error);
+				span.end();
+				throw error;
+			}
+		},
+		async return(value?: any) {
+			span.setStatus({ code: SpanStatusCode.OK });
+			span.end();
+			if (iterator.return) {
+				return iterator.return(value);
+			}
+			return { done: true as const, value };
+		},
+		async throw(error?: any) {
+			span.setStatus({ code: SpanStatusCode.ERROR, message: error?.message });
+			span.recordException(error);
+			span.end();
+			if (iterator.throw) {
+				return iterator.throw(error);
+			}
+			throw error;
+		},
+	};
+}
+
+function wrapStream(stream: any, span: Span, config: OtelPatchConfig): any {
+	const originalIterator = stream[Symbol.asyncIterator]();
+	const wrappedIterator = wrapAsyncIterator(originalIterator, span, config);
+
+	return new Proxy(stream, {
+		get(target, prop) {
+			if (prop === Symbol.asyncIterator) {
+				return () => wrappedIterator;
+			}
+			const value = target[prop];
+			if (typeof value === 'function') {
+				return value.bind(target);
+			}
+			return value;
+		},
+	});
+}
+
+function createOtelWrapper(
+	originalCreate: (...args: any[]) => any,
+	config: OtelPatchConfig
+): (body: any, options?: any) => any {
+	return function _agentuityOtelCreate(this: any, body: any, options?: any) {
+		const attributes: Record<string, any> = {
+			[ATTR_GEN_AI_SYSTEM]: config.provider,
+			[ATTR_GEN_AI_OPERATION_NAME]: 'chat',
+		};
+
+		if (body.model) attributes[ATTR_GEN_AI_REQUEST_MODEL] = body.model;
+		if (body.max_tokens) attributes[ATTR_GEN_AI_REQUEST_MAX_TOKENS] = body.max_tokens;
+		if (body.temperature !== undefined)
+			attributes[ATTR_GEN_AI_REQUEST_TEMPERATURE] = body.temperature;
+		if (body.top_p !== undefined) attributes[ATTR_GEN_AI_REQUEST_TOP_P] = body.top_p;
+		if (body.frequency_penalty !== undefined)
+			attributes[ATTR_GEN_AI_REQUEST_FREQUENCY_PENALTY] = body.frequency_penalty;
+		if (body.presence_penalty !== undefined)
+			attributes[ATTR_GEN_AI_REQUEST_PRESENCE_PENALTY] = body.presence_penalty;
+
+		// Capture request messages
+		const messages = body[config.requestMessagesField];
+		if (messages && Array.isArray(messages)) {
+			try {
+				attributes[ATTR_GEN_AI_REQUEST_MESSAGES] = JSON.stringify(messages);
+			} catch {
+				// Ignore serialization errors
+			}
+		}
+
+		const spanName = body.model ? `chat ${body.model}` : 'chat';
+
+		return otelTracer.startActiveSpan(
+			spanName,
+			{ attributes, kind: SpanKind.CLIENT },
+			(span: Span) => {
+				let result: any;
+				try {
+					result = originalCreate.call(this, body, options);
+				} catch (error: any) {
+					span.setStatus({ code: SpanStatusCode.ERROR, message: error?.message });
+					span.recordException(error);
+					span.end();
+					throw error;
+				}
+
+				// Handle streaming responses
+				if (body.stream) {
+					if (result && typeof result.then === 'function') {
+						return result
+							.then((stream: any) => {
+								try {
+									return wrapStream(stream, span, config);
+								} catch (error: any) {
+									span.setStatus({
+										code: SpanStatusCode.ERROR,
+										message: error?.message,
+									});
+									span.recordException(error);
+									span.end();
+									throw error;
+								}
+							})
+							.catch((error: any) => {
+								span.setStatus({ code: SpanStatusCode.ERROR, message: error?.message });
+								span.recordException(error);
+								span.end();
+								throw error;
+							});
+					}
+					try {
+						return wrapStream(result, span, config);
+					} catch (error: any) {
+						span.setStatus({ code: SpanStatusCode.ERROR, message: error?.message });
+						span.recordException(error);
+						span.end();
+						throw error;
+					}
+				}
+
+				// Handle non-streaming responses
+				if (result && typeof result.then === 'function') {
+					return result
+						.then((response: any) => {
+							if (response) {
+								if (response.model) {
+									span.setAttribute(ATTR_GEN_AI_RESPONSE_MODEL, response.model);
+								}
+								if (response[config.responseIdField]) {
+									span.setAttribute(
+										ATTR_GEN_AI_RESPONSE_ID,
+										response[config.responseIdField]
+									);
+								}
+								if (response.usage) {
+									if (response.usage[config.inputTokensField] !== undefined) {
+										span.setAttribute(
+											ATTR_GEN_AI_USAGE_INPUT_TOKENS,
+											response.usage[config.inputTokensField]
+										);
+									}
+									if (response.usage[config.outputTokensField] !== undefined) {
+										span.setAttribute(
+											ATTR_GEN_AI_USAGE_OUTPUT_TOKENS,
+											response.usage[config.outputTokensField]
+										);
+									}
+								}
+								const finishReason = config.finishReasonExtractor(response);
+								if (finishReason) {
+									span.setAttribute(
+										ATTR_GEN_AI_RESPONSE_FINISH_REASONS,
+										JSON.stringify([finishReason])
+									);
+								}
+								const responseContent = config.responseContentExtractor(response);
+								if (responseContent) {
+									span.setAttribute(ATTR_GEN_AI_RESPONSE_TEXT, responseContent);
+								}
+							}
+							span.setStatus({ code: SpanStatusCode.OK });
+							span.end();
+							return response;
+						})
+						.catch((error: any) => {
+							span.setStatus({ code: SpanStatusCode.ERROR, message: error?.message });
+							span.recordException(error);
+							span.end();
+							throw error;
+						});
+				}
+
+				span.end();
+				return result;
+			}
+		);
+	};
+}
+
+/** Provider-specific configurations matching the build-time patches */
+const OTEL_CONFIGS: Array<{
+	module: string;
+	className: string;
+	config: OtelPatchConfig;
+}> = [
+	{
+		module: 'openai',
+		// In the openai SDK, the Completions class is in resources/chat/completions
+		// We need to import the main module and access the prototype
+		className: 'Completions',
+		config: {
+			provider: 'openai',
+			inputTokensField: 'prompt_tokens',
+			outputTokensField: 'completion_tokens',
+			responseIdField: 'id',
+			finishReasonExtractor: (r) => r?.choices?.[0]?.finish_reason,
+			responseContentExtractor: (r) => r?.choices?.[0]?.message?.content,
+			requestMessagesField: 'messages',
+			streamDeltaContentExtractor: (c) => c?.choices?.[0]?.delta?.content,
+			streamFinishReasonExtractor: (c) => c?.choices?.[0]?.finish_reason,
+			streamUsageExtractor: (c) => c?.usage,
+		},
+	},
+	{
+		module: '@anthropic-ai/sdk',
+		className: 'Messages',
+		config: {
+			provider: 'anthropic',
+			inputTokensField: 'input_tokens',
+			outputTokensField: 'output_tokens',
+			responseIdField: 'id',
+			finishReasonExtractor: (r) => r?.stop_reason,
+			responseContentExtractor: (r) => r?.content?.[0]?.text,
+			requestMessagesField: 'messages',
+			streamDeltaContentExtractor: (c) => c?.delta?.text,
+			streamFinishReasonExtractor: (c) => c?.delta?.stop_reason,
+			streamUsageExtractor: (c) => c?.usage,
+		},
+	},
+	{
+		module: 'groq-sdk',
+		className: 'Completions',
+		config: {
+			provider: 'groq',
+			inputTokensField: 'prompt_tokens',
+			outputTokensField: 'completion_tokens',
+			responseIdField: 'id',
+			finishReasonExtractor: (r) => r?.choices?.[0]?.finish_reason,
+			responseContentExtractor: (r) => r?.choices?.[0]?.message?.content,
+			requestMessagesField: 'messages',
+			streamDeltaContentExtractor: (c) => c?.choices?.[0]?.delta?.content,
+			streamFinishReasonExtractor: (c) => c?.choices?.[0]?.finish_reason,
+			streamUsageExtractor: (c) => c?.x_groq?.usage,
+		},
+	},
+];
+
+/**
+ * Find a class prototype by name within a module's exports (recursive search).
+ * The SDKs nest classes in sub-objects (e.g., openai.Chat.Completions).
+ */
+function findPrototype(obj: any, className: string, depth = 0): any | null {
+	if (depth > 5 || !obj || typeof obj !== 'object') return null;
+
+	// Check if this object itself is the class we're looking for
+	if (typeof obj === 'function' && obj.name === className && obj.prototype?.create) {
+		return obj.prototype;
+	}
+
+	// Search properties
+	for (const key of Object.keys(obj)) {
+		try {
+			const val = obj[key];
+			if (typeof val === 'function' && val.name === className && val.prototype?.create) {
+				return val.prototype;
+			}
+			if (typeof val === 'object' && val !== null) {
+				const found = findPrototype(val, className, depth + 1);
+				if (found) return found;
+			}
+		} catch {
+			// Skip inaccessible properties
+		}
+	}
+	return null;
+}
+
+/**
+ * Apply OTel instrumentation patches to LLM SDK prototype methods.
+ */
+export async function applyOtelLLMPatches(): Promise<void> {
+	for (const { module: moduleName, className, config } of OTEL_CONFIGS) {
+		try {
+			const mod = await import(moduleName);
+			const proto = findPrototype(mod, className);
+
+			if (!proto || typeof proto.create !== 'function') {
+				console.debug(
+					`[Agentuity OTel] Skipping patch: ${className}.prototype.create not found in ${moduleName}`
+				);
+				continue;
+			}
+
+			const originalCreate = proto.create;
+			proto.create = createOtelWrapper(originalCreate, config);
+		} catch {
+			// Module not installed — skip
+		}
+	}
+}

package/src/index.ts

@@ -263,3 +263,6 @@ export { bootstrapRuntimeEnv, type RuntimeBootstrapOptions, mimeTypes } from '@a
 
 // bun-s3-patch.ts exports
 export { patchBunS3ForStorageDev, isAgentuityStorageEndpoint } from './bun-s3-patch';
+
+// dev-patches exports (runtime monkey-patches for --experimental-no-bundle dev mode)
+export { applyDevPatches } from './dev-patches';

package/src/services/local/_db.ts

@@ -115,12 +115,20 @@ function initializeTables(db: Database): void {
 			created_id TEXT NOT NULL,
 			assigned_id TEXT,
 			closed_id TEXT,
+			deleted INTEGER NOT NULL DEFAULT 0,
 			created_at INTEGER NOT NULL,
 			updated_at INTEGER NOT NULL,
 			PRIMARY KEY (project_path, id)
 		)
 	`);
 
+	// Migration: add deleted column for existing databases
+	try {
+		db.run('ALTER TABLE task_storage ADD COLUMN deleted INTEGER NOT NULL DEFAULT 0');
+	} catch {
+		// Column already exists
+	}
+
 	// Task Changelog table
 	db.run(`
 		CREATE TABLE IF NOT EXISTS task_changelog_storage (
@@ -139,6 +147,57 @@ function initializeTables(db: Database): void {
 		CREATE INDEX IF NOT EXISTS idx_task_changelog_lookup
 		ON task_changelog_storage(project_path, task_id)
 	`);
+
+	// Task Comment table
+	db.run(`
+		CREATE TABLE IF NOT EXISTS task_comment_storage (
+			project_path TEXT NOT NULL,
+			id TEXT NOT NULL,
+			task_id TEXT NOT NULL,
+			user_id TEXT NOT NULL,
+			body TEXT NOT NULL,
+			created_at INTEGER NOT NULL,
+			updated_at INTEGER NOT NULL,
+			PRIMARY KEY (project_path, id)
+		)
+	`);
+
+	db.run(`
+		CREATE INDEX IF NOT EXISTS idx_task_comment_lookup
+		ON task_comment_storage(project_path, task_id)
+	`);
+
+	// Task Tag table
+	db.run(`
+		CREATE TABLE IF NOT EXISTS task_tag_storage (
+			project_path TEXT NOT NULL,
+			id TEXT NOT NULL,
+			name TEXT NOT NULL,
+			color TEXT,
+			created_at INTEGER NOT NULL,
+			PRIMARY KEY (project_path, id)
+		)
+	`);
+
+	// Task-Tag association table
+	db.run(`
+		CREATE TABLE IF NOT EXISTS task_tag_association_storage (
+			project_path TEXT NOT NULL,
+			task_id TEXT NOT NULL,
+			tag_id TEXT NOT NULL,
+			PRIMARY KEY (project_path, task_id, tag_id)
+		)
+	`);
+
+	db.run(`
+		CREATE INDEX IF NOT EXISTS idx_task_tag_assoc_task
+		ON task_tag_association_storage(project_path, task_id)
+	`);
+
+	db.run(`
+		CREATE INDEX IF NOT EXISTS idx_task_tag_assoc_tag
+		ON task_tag_association_storage(project_path, tag_id)
+	`);
 }
 
 function cleanupOrphanedProjects(db: Database): void {
@@ -163,14 +222,36 @@ function cleanupOrphanedProjects(db: Database): void {
 		.all() as Array<{
 		project_path: string;
 	}>;
+	const taskCommentPaths = db
+		.query('SELECT DISTINCT project_path FROM task_comment_storage')
+		.all() as Array<{
+		project_path: string;
+	}>;
+	const taskTagPaths = db
+		.query('SELECT DISTINCT project_path FROM task_tag_storage')
+		.all() as Array<{
+		project_path: string;
+	}>;
+	const taskTagAssocPaths = db
+		.query('SELECT DISTINCT project_path FROM task_tag_association_storage')
+		.all() as Array<{
+		project_path: string;
+	}>;
 
 	// Combine and deduplicate all project paths
 	const allPaths = new Set<string>();
-	[...kvPaths, ...streamPaths, ...vectorPaths, ...taskPaths, ...taskChangelogPaths].forEach(
-		(row) => {
-			allPaths.add(row.project_path);
-		}
-	);
+	[
+		...kvPaths,
+		...streamPaths,
+		...vectorPaths,
+		...taskPaths,
+		...taskChangelogPaths,
+		...taskCommentPaths,
+		...taskTagPaths,
+		...taskTagAssocPaths,
+	].forEach((row) => {
+		allPaths.add(row.project_path);
+	});
 
 	// Check which paths no longer exist and are not the current project
 	const pathsToDelete: string[] = [];
@@ -198,12 +279,24 @@ function cleanupOrphanedProjects(db: Database): void {
 		const deleteTaskChangelog = db.prepare(
 			`DELETE FROM task_changelog_storage WHERE project_path IN (${placeholders})`
 		);
+		const deleteTaskComments = db.prepare(
+			`DELETE FROM task_comment_storage WHERE project_path IN (${placeholders})`
+		);
+		const deleteTaskTags = db.prepare(
+			`DELETE FROM task_tag_storage WHERE project_path IN (${placeholders})`
+		);
+		const deleteTaskTagAssoc = db.prepare(
+			`DELETE FROM task_tag_association_storage WHERE project_path IN (${placeholders})`
+		);
 
 		deleteKv.run(...pathsToDelete);
 		deleteStream.run(...pathsToDelete);
 		deleteVector.run(...pathsToDelete);
 		deleteTasks.run(...pathsToDelete);
 		deleteTaskChangelog.run(...pathsToDelete);
+		deleteTaskComments.run(...pathsToDelete);
+		deleteTaskTags.run(...pathsToDelete);
+		deleteTaskTagAssoc.run(...pathsToDelete);
 
 		console.log(`[LocalDB] Cleaned up data for ${pathsToDelete.length} orphaned project(s)`);
 	}

package/src/services/local/email.ts

@@ -11,10 +11,7 @@ import {
 const ERROR_MESSAGE =
 	'Email service is not available in local development mode. Deploy to Agentuity Cloud to use email.';
 
-const LocalEmailNotAvailableError = StructuredError(
-	'LocalEmailNotAvailableError',
-	ERROR_MESSAGE
-);
+const LocalEmailNotAvailableError = StructuredError('LocalEmailNotAvailableError', ERROR_MESSAGE);
 
 /**
  * Local development stub for the email service.
@@ -65,6 +62,10 @@ export class LocalEmailStorage implements EmailService {
 		throw new LocalEmailNotAvailableError();
 	}
 
+	async deleteInbound(_id: string): Promise<void> {
+		throw new LocalEmailNotAvailableError();
+	}
+
 	async listOutbound(_addressId?: string): Promise<EmailOutbound[]> {
 		throw new LocalEmailNotAvailableError();
 	}
@@ -72,4 +73,8 @@ export class LocalEmailStorage implements EmailService {
 	async getOutbound(_id: string): Promise<EmailOutbound | null> {
 		throw new LocalEmailNotAvailableError();
 	}
+
+	async deleteOutbound(_id: string): Promise<void> {
+		throw new LocalEmailNotAvailableError();
+	}
 }