veryfront 0.1.21 → 0.1.23

package/esm/src/task/discovery.js

@@ -0,0 +1,149 @@
+/**
+ * Task Discovery
+ *
+ * Discovers task definitions from user's project `tasks/` directory.
+ * Follows the same patterns as workflow-discovery.ts.
+ *
+ * Scans:
+ * - tasks/*.ts - task definition files
+ * - tasks/**\/*.ts - nested task files
+ *
+ * Task files should export a task definition:
+ * ```typescript
+ * export default {
+ *   name: "Sync external data",
+ *   run: async (ctx) => {
+ *     console.log("Syncing data...")
+ *     return { synced: 42 }
+ *   }
+ * }
+ * ```
+ */
+import { join } from "../../deps/jsr.io/@std/path/1.1.4/mod.js";
+import { logger as baseLogger } from "../utils/index.js";
+import { collectFiles } from "../utils/file-discovery.js";
+import { loadHandlerModule } from "../routing/api/module-loader/loader.js";
+import { isTaskDefinition } from "./types.js";
+const logger = baseLogger.component("task-discovery");
+/**
+ * Derive task ID from file path (e.g., "tasks/sync-data.ts" → "sync-data")
+ */
+export function deriveTaskId(filePath, tasksDir) {
+    // Remove the tasks dir prefix and extension
+    let relative = filePath;
+    const dirPrefix = tasksDir.endsWith("/") ? tasksDir : `${tasksDir}/`;
+    if (relative.startsWith(dirPrefix)) {
+        relative = relative.slice(dirPrefix.length);
+    }
+    // Remove extension
+    return relative.replace(/\.(ts|tsx|js|jsx)$/, "");
+}
+/**
+ * Discover all tasks in a project
+ */
+export async function discoverTasks(options) {
+    const { projectDir, adapter, config, tasksDir = "tasks", debug = false, } = options;
+    const tasks = [];
+    const errors = [];
+    const fsType = config?.fs?.type ?? "local";
+    const useRelativePaths = fsType === "github" || fsType === "veryfront-api";
+    const baseDir = useRelativePaths ? tasksDir : join(projectDir, tasksDir);
+    if (debug) {
+        logger.info(`Scanning ${baseDir} for tasks`);
+    }
+    try {
+        const dirExists = await adapter.fs.exists(baseDir);
+        if (!dirExists) {
+            if (debug) {
+                logger.info(`No tasks directory found at ${baseDir}`);
+            }
+            return { tasks, errors };
+        }
+        const files = await collectFiles({
+            baseDir,
+            extensions: [".ts", ".tsx", ".js", ".jsx"],
+            recursive: true,
+            ignorePatterns: ["node_modules", ".git", "__tests__", "*.test.*", "*.spec.*"],
+            adapter,
+        });
+        if (debug) {
+            logger.info(`Found ${files.length} potential task files`);
+        }
+        for (const file of files) {
+            try {
+                const module = await loadHandlerModule({
+                    projectDir,
+                    modulePath: file.path,
+                    adapter,
+                    config,
+                });
+                if (!module)
+                    continue;
+                // Prefer default export (aligned with discovery-engine behaviour)
+                const defaultExport = module.default;
+                if (isTaskDefinition(defaultExport)) {
+                    const id = deriveTaskId(file.path, baseDir);
+                    tasks.push({
+                        id,
+                        name: defaultExport.name || id,
+                        filePath: file.path,
+                        exportName: "default",
+                        definition: defaultExport,
+                    });
+                    if (debug) {
+                        logger.info(`Found task "${id}" in ${file.path} (export: default)`);
+                    }
+                }
+                else {
+                    // Fallback: check named exports
+                    for (const [exportName, value] of Object.entries(module)) {
+                        if (exportName === "default")
+                            continue;
+                        if (isTaskDefinition(value)) {
+                            const id = deriveTaskId(file.path, baseDir);
+                            tasks.push({
+                                id,
+                                name: value.name || id,
+                                filePath: file.path,
+                                exportName,
+                                definition: value,
+                            });
+                            if (debug) {
+                                logger.info(`Found task "${id}" in ${file.path} (export: ${exportName})`);
+                            }
+                            break; // Only take the first valid named export per file
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                errors.push({ filePath: file.path, error: errorMsg });
+                if (debug) {
+                    logger.warn(`Failed to load ${file.path}: ${errorMsg}`);
+                }
+            }
+        }
+        if (debug) {
+            logger.info(`Discovered ${tasks.length} tasks`);
+        }
+        return { tasks, errors };
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        logger.error(`Task discovery failed: ${errorMsg}`);
+        errors.push({ filePath: baseDir, error: errorMsg });
+        return { tasks, errors };
+    }
+}
+/**
+ * Find a specific task by ID
+ *
+ * TODO: Optimise by short-circuiting discovery once the target task is found
+ * instead of discovering all tasks first. This is consistent with the workflow
+ * pattern but could be improved for large projects with many task files.
+ */
+export async function findTaskById(taskId, options) {
+    const { tasks } = await discoverTasks(options);
+    return tasks.find((t) => t.id === taskId) ?? null;
+}

package/esm/src/task/runner.d.ts

@@ -0,0 +1,34 @@
+import type { DiscoveredTask } from "./discovery.js";
+/**
+ * Options for running a task
+ */
+export interface RunTaskOptions {
+    /** The discovered task to run */
+    task: DiscoveredTask;
+    /** Additional config to pass to the task */
+    config?: Record<string, unknown>;
+    /** Project ID (for cloud context) */
+    projectId?: string;
+    /** If set, only these env var names are passed to the task. */
+    envAllowlist?: string[];
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * Result of running a task
+ */
+export interface TaskRunResult {
+    /** Whether the task completed successfully */
+    success: boolean;
+    /** Return value from the task's run() */
+    result?: unknown;
+    /** Error if the task failed */
+    error?: string;
+    /** Execution duration in milliseconds */
+    durationMs: number;
+}
+/**
+ * Run a task with the given options
+ */
+export declare function runTask(options: RunTaskOptions): Promise<TaskRunResult>;
+//# sourceMappingURL=runner.d.ts.map

package/esm/src/task/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../src/src/task/runner.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAKrD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,iCAAiC;IACjC,IAAI,EAAE,cAAc,CAAC;IAErB,4CAA4C;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEjC,qCAAqC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,+DAA+D;IAC/D,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IAExB,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,8CAA8C;IAC9C,OAAO,EAAE,OAAO,CAAC;IAEjB,yCAAyC;IACzC,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB,+BAA+B;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,yCAAyC;IACzC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,wBAAsB,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CAsC7E"}

package/esm/src/task/runner.js

@@ -0,0 +1,45 @@
+/**
+ * Task Runner
+ *
+ * Executes a discovered task by calling its run() function
+ * with the appropriate context.
+ */
+import * as dntShim from "../../_dnt.shims.js";
+import { logger as baseLogger } from "../utils/index.js";
+const logger = baseLogger.component("task-runner");
+/**
+ * Run a task with the given options
+ */
+export async function runTask(options) {
+    const { task, config = {}, projectId, envAllowlist, debug = false } = options;
+    const start = Date.now();
+    if (debug) {
+        logger.info(`Running task "${task.id}" (${task.name})`);
+    }
+    const env = { ...dntShim.Deno.env.toObject() };
+    if (envAllowlist) {
+        for (const k of Object.keys(env)) {
+            if (!envAllowlist.includes(k))
+                delete env[k];
+        }
+    }
+    const ctx = {
+        env,
+        config,
+        projectId,
+    };
+    try {
+        const result = await task.definition.run(ctx);
+        const durationMs = Date.now() - start;
+        if (debug) {
+            logger.info(`Task "${task.id}" completed in ${durationMs}ms`);
+        }
+        return { success: true, result, durationMs };
+    }
+    catch (error) {
+        const durationMs = Date.now() - start;
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        logger.error(`Task "${task.id}" failed: ${errorMsg}`);
+        return { success: false, error: errorMsg, durationMs };
+    }
+}

package/esm/src/task/types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Task Types
+ *
+ * Type definitions for the task execution system.
+ * Tasks are user-defined functions in `tasks/` that can run
+ * locally via `veryfront task <name>` or in the cloud as Jobs/CronJobs.
+ */
+/**
+ * Context passed to task run() function
+ */
+export interface TaskContext {
+    /** Environment variables */
+    env: Record<string, string>;
+    /** Job config (when run as a cloud job) */
+    config: Record<string, unknown>;
+    /** Project ID (when run as a cloud job) */
+    projectId?: string;
+}
+/**
+ * Task definition exported from a tasks/ file
+ */
+export interface TaskDefinition {
+    /** Human-readable name */
+    name?: string;
+    /** Task description */
+    description?: string;
+    /** The function to execute */
+    run: (ctx: TaskContext) => Promise<unknown> | unknown;
+}
+/**
+ * Type guard: checks if a value looks like a TaskDefinition
+ */
+export declare function isTaskDefinition(value: unknown): value is TaskDefinition;
+//# sourceMappingURL=types.d.ts.map

package/esm/src/task/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/src/task/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,4BAA4B;IAC5B,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,2CAA2C;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,0BAA0B;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,uBAAuB;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8BAA8B;IAC9B,GAAG,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;CACvD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAIxE"}

package/esm/src/task/types.js

@@ -0,0 +1,16 @@
+/**
+ * Task Types
+ *
+ * Type definitions for the task execution system.
+ * Tasks are user-defined functions in `tasks/` that can run
+ * locally via `veryfront task <name>` or in the cloud as Jobs/CronJobs.
+ */
+/**
+ * Type guard: checks if a value looks like a TaskDefinition
+ */
+export function isTaskDefinition(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const obj = value;
+    return typeof obj.run === "function";
+}

package/esm/src/transforms/mdx/esm-module-loader/jsx/runtime-loader.js

@@ -1,6 +1,6 @@
 export async function loadJSXRuntime() {
     // deno-lint-ignore no-explicit-any
-    const runtime = (await import("../../../../../deps/esm.sh/react@19.1.1/jsx-dev-runtime.js"));
+    const runtime = (await import("react/jsx-dev-runtime"));
     return {
         Fragment: runtime.Fragment,
         jsx: runtime.jsx ?? runtime.jsxDEV,

package/esm/src/workflow/claude-code/tool.d.ts

@@ -24,8 +24,8 @@ declare const claudeCodeInputSchema: z.ZodObject<{
     system: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     mode: "code" | "custom" | "full" | "analysis";
-    maxTurns: number;
     task: string;
+    maxTurns: number;
     context?: Record<string, unknown> | undefined;
     files?: string[] | undefined;
     system?: string | undefined;
@@ -77,8 +77,8 @@ export declare function createClaudeCodeTool(options?: {
 /** Code review tool (analysis mode, read-only) */
 export declare const codeReviewTool: Tool<{
     mode: "code" | "custom" | "full" | "analysis";
-    maxTurns: number;
     task: string;
+    maxTurns: number;
     context?: Record<string, unknown> | undefined;
     files?: string[] | undefined;
     system?: string | undefined;
@@ -86,8 +86,8 @@ export declare const codeReviewTool: Tool<{
 /** Bug fix tool (code mode) */
 export declare const bugFixTool: Tool<{
     mode: "code" | "custom" | "full" | "analysis";
-    maxTurns: number;
     task: string;
+    maxTurns: number;
     context?: Record<string, unknown> | undefined;
     files?: string[] | undefined;
     system?: string | undefined;
@@ -95,8 +95,8 @@ export declare const bugFixTool: Tool<{
 /** Refactoring tool (code mode) */
 export declare const refactorTool: Tool<{
     mode: "code" | "custom" | "full" | "analysis";
-    maxTurns: number;
     task: string;
+    maxTurns: number;
     context?: Record<string, unknown> | undefined;
     files?: string[] | undefined;
     system?: string | undefined;
@@ -104,8 +104,8 @@ export declare const refactorTool: Tool<{
 /** Documentation tool (code mode) */
 export declare const docsTool: Tool<{
     mode: "code" | "custom" | "full" | "analysis";
-    maxTurns: number;
     task: string;
+    maxTurns: number;
     context?: Record<string, unknown> | undefined;
     files?: string[] | undefined;
     system?: string | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veryfront",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "description": "The simplest way to build AI-powered apps",
   "keywords": [
     "react",
@@ -19,7 +19,7 @@
     "type": "git",
     "url": "git+https://github.com/veryfront/veryfront.git"
   },
-  "license": "MIT",
+  "license": "Apache-2.0",
   "bugs": {
     "url": "https://github.com/veryfront/veryfront/issues"
   },

package/src/cli/commands/task/command-help.ts

@@ -0,0 +1,22 @@
+import type { CommandHelp } from "../../help/types.js";
+
+export const taskHelp: CommandHelp = {
+  name: "task",
+  description: "Run a task from the tasks/ directory",
+  usage: "veryfront task <name> [options]",
+  options: [
+    {
+      flag: "--config <json>",
+      description: "JSON config to pass to the task's ctx.config",
+    },
+    {
+      flag: "--debug",
+      description: "Enable debug logging",
+    },
+  ],
+  examples: [
+    "veryfront task sync-data",
+    'veryfront task send-report --config \'{"to": "team@example.com"}\'',
+    "veryfront task cleanup --debug",
+  ],
+};

package/src/cli/commands/task/command.ts

@@ -0,0 +1,98 @@
+/**
+ * Task command - Discover and run a task from the tasks/ directory
+ *
+ * Finds the specified task file, imports it, and calls its run() function
+ * with a local execution context.
+ */
+import * as dntShim from "../../../_dnt.shims.js";
+
+
+import { cliLogger } from "../../utils/index.js";
+import { exitProcess } from "../../utils/index.js";
+import type { TaskArgs } from "./handler.js";
+
+export interface TaskOptions extends TaskArgs {}
+
+export async function taskCommand(options: TaskOptions): Promise<void> {
+  const { getAdapter } = await import(
+    "../../../src/platform/adapters/detect.js"
+  );
+  const { discoverTasks } = await import(
+    "../../../src/task/discovery.js"
+  );
+  const { runTask } = await import(
+    "../../../src/task/runner.js"
+  );
+
+  const taskName = options.name;
+  if (!taskName) {
+    cliLogger.error("Task name is required. Usage: veryfront task <name>");
+    exitProcess(1);
+    return;
+  }
+
+  const projectDir = dntShim.Deno.cwd();
+  const adapter = await getAdapter();
+
+  cliLogger.info(`Discovering tasks in ${projectDir}/tasks/...`);
+
+  const { tasks, errors } = await discoverTasks({
+    projectDir,
+    adapter,
+    debug: options.debug,
+  });
+
+  if (errors.length > 0 && options.debug) {
+    for (const err of errors) {
+      cliLogger.warn(`  Warning: ${err.filePath}: ${err.error}`);
+    }
+  }
+
+  const task = tasks.find((t) => t.id === taskName);
+  if (!task) {
+    cliLogger.error(`Task "${taskName}" not found.`);
+    if (tasks.length > 0) {
+      cliLogger.info("Available tasks:");
+      for (const t of tasks) {
+        cliLogger.info(`  - ${t.id}${t.name !== t.id ? ` (${t.name})` : ""}`);
+      }
+    } else {
+      cliLogger.info("No tasks found. Create a task file in tasks/ directory:");
+      cliLogger.info("  tasks/my-task.ts");
+    }
+    exitProcess(1);
+    return;
+  }
+
+  // Parse config JSON if provided
+  let config: Record<string, unknown> = {};
+  if (options.config) {
+    try {
+      config = JSON.parse(options.config);
+    } catch {
+      cliLogger.error("Invalid --config JSON");
+      exitProcess(1);
+      return;
+    }
+  }
+
+  cliLogger.info(`Running task: ${task.name} (${task.id})`);
+  cliLogger.info("");
+
+  const result = await runTask({
+    task,
+    config,
+    debug: options.debug,
+  });
+
+  cliLogger.info("");
+  if (result.success) {
+    cliLogger.info(`Task completed in ${result.durationMs}ms`);
+    if (result.result !== undefined) {
+      cliLogger.info(`Result: ${JSON.stringify(result.result, null, 2)}`);
+    }
+  } else {
+    cliLogger.error(`Task failed after ${result.durationMs}ms: ${result.error}`);
+    exitProcess(1);
+  }
+}

package/src/cli/commands/task/handler.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { createArgParser, parseArgsOrThrow } from "../../shared/args.js";
+import type { ParsedArgs } from "../../shared/types.js";
+
+const TaskArgsSchema = z.object({
+  name: z.string(),
+  config: z.string().optional(),
+  debug: z.boolean().default(false),
+});
+
+export type TaskArgs = z.infer<typeof TaskArgsSchema>;
+
+export const parseTaskArgs = createArgParser(TaskArgsSchema, {
+  name: { keys: ["name"], type: "string", positional: 0 },
+  config: { keys: ["config"], type: "string" },
+  debug: { keys: ["debug"], type: "boolean" },
+});
+
+export async function handleTaskCommand(args: ParsedArgs): Promise<void> {
+  const opts = parseArgsOrThrow(parseTaskArgs, "task", args);
+  const { taskCommand } = await import("./command.js");
+  await taskCommand(opts);
+}

package/src/cli/help/command-definitions.ts

@@ -32,6 +32,7 @@ import { demoHelp } from "../commands/demo/command-help.js";
 import { mcpHelp } from "../commands/mcp/command-help.js";
 import { issuesHelp } from "../commands/issues/command-help.js";
 import { startHelp } from "../commands/start/command-help.js";
+import { taskHelp } from "../commands/task/command-help.js";
 
 /**
  * Central registry of all command help definitions.
@@ -63,4 +64,5 @@ export const COMMANDS: CommandRegistry = {
   mcp: mcpHelp,
   issues: issuesHelp,
   start: startHelp,
+  task: taskHelp,
 };

package/src/cli/router.ts

@@ -27,6 +27,7 @@ import { handleServeCommand } from "./commands/serve/handler.js";
 import { handleStartCommand } from "./commands/start/handler.js";
 import { handleStudioCommand } from "./commands/studio/handler.js";
 import { handleUpCommand } from "./commands/up/index.js";
+import { handleTaskCommand } from "./commands/task/handler.js";
 import { handleWorkerCommand } from "./commands/worker/handler.js";
 import { login, logout, whoami } from "./auth/index.js";
 import { parseLoginMethod } from "./auth/utils.js";
@@ -73,6 +74,7 @@ const commands: Record<string, (args: ParsedArgs) => Promise<void>> = {
   "mcp": handleMCPCommand,
   "issues": handleIssuesCommand,
   "start": handleStartCommand,
+  "task": handleTaskCommand,
   "worker": handleWorkerCommand,
 };
 

package/src/deno.js

@@ -1,6 +1,7 @@
 export default {
   "name": "veryfront",
-  "version": "0.1.21",
+  "version": "0.1.23",
+  "license": "Apache-2.0",
   "nodeModulesDir": "auto",
   "exclude": [
     "npm/",

package/src/src/discovery/discovery-engine.ts

@@ -20,6 +20,7 @@ import {
   agentHandler,
   promptHandler,
   resourceHandler,
+  taskHandler,
   toolHandler,
   workflowHandler,
 } from "./handlers/index.js";
@@ -89,6 +90,7 @@ export async function discoverAll(config: DiscoveryConfig): Promise<DiscoveryRes
     resources: new Map(),
     prompts: new Map(),
     workflows: new Map(),
+    tasks: new Map(),
     errors: [],
   };
 
@@ -117,5 +119,10 @@ export async function discoverAll(config: DiscoveryConfig): Promise<DiscoveryRes
     await discoverItems(`${baseDir}/${dir}`, result, context, workflowHandler, config.verbose);
   }
 
+  // Discover tasks
+  for (const dir of config.taskDirs ?? ["tasks"]) {
+    await discoverItems(`${baseDir}/${dir}`, result, context, taskHandler, config.verbose);
+  }
+
   return result;
 }

package/src/src/discovery/handlers/index.ts

@@ -9,3 +9,4 @@ export { agentHandler } from "./agent-handler.js";
 export { resourceHandler } from "./resource-handler.js";
 export { promptHandler } from "./prompt-handler.js";
 export { workflowHandler } from "./workflow-handler.js";
+export { taskHandler } from "./task-handler.js";

package/src/src/discovery/handlers/task-handler.ts

@@ -0,0 +1,23 @@
+/**
+ * Task Discovery Handler
+ */
+
+import type { TaskDefinition } from "../../task/types.js";
+import { isTaskDefinition } from "../../task/types.js";
+import type { DiscoveryHandler, DiscoveryResult } from "../types.js";
+
+export const taskHandler: DiscoveryHandler<TaskDefinition> = {
+  typeName: "task",
+  validate: (item): item is TaskDefinition => isTaskDefinition(item),
+  getId: (_task, file, dir) => {
+    // Derive ID from file path relative to tasks dir
+    let relative = file;
+    const prefix = dir.endsWith("/") ? dir : `${dir}/`;
+    if (relative.startsWith(prefix)) {
+      relative = relative.slice(prefix.length);
+    }
+    return relative.replace(/\.(ts|tsx|js|jsx)$/, "");
+  },
+  register: (_id, task) => task,
+  getResultMap: (result: DiscoveryResult) => result.tasks,
+};

package/src/src/discovery/types.ts

@@ -9,6 +9,7 @@ import type { Agent } from "../agent/index.js";
 import type { Resource } from "../resource/index.js";
 import type { Prompt } from "../prompt/index.js";
 import type { Workflow } from "../workflow/index.js";
+import type { TaskDefinition } from "../task/types.js";
 import type { Platform } from "../platform/core-platform.js";
 import type { FileSystemAdapter } from "../platform/adapters/base.js";
 
@@ -35,6 +36,7 @@ export interface DiscoveryConfig {
   resourceDirs?: string[];
   promptDirs?: string[];
   workflowDirs?: string[];
+  taskDirs?: string[];
   verbose?: boolean;
   fsAdapter?: FileSystemAdapter;
 }
@@ -48,6 +50,7 @@ export interface DiscoveryResult {
   resources: Map<string, Resource>;
   prompts: Map<string, Prompt>;
   workflows: Map<string, Workflow>;
+  tasks: Map<string, TaskDefinition>;
   errors: Array<{ file: string; error: Error }>;
 }
 

package/src/src/platform/adapters/fs/veryfront/adapter.ts

@@ -42,8 +42,6 @@ export class VeryfrontFSAdapter implements FSAdapter {
 
   /** Resolves when file list initialization is complete (for coordinating reads) */
   private fileListReadyResolve: (() => void) | null = null;
-  /** Rejects when file list initialization fails */
-  private fileListReadyReject: ((error: Error) => void) | null = null;
 
   private projectData?: Project;
   private apiBaseUrl: string;
@@ -233,9 +231,8 @@ export class VeryfrontFSAdapter implements FSAdapter {
       return;
     }
 
-    const fileListReadyPromise = new Promise<void>((resolve, reject) => {
+    const fileListReadyPromise = new Promise<void>((resolve) => {
       this.fileListReadyResolve = resolve;
-      this.fileListReadyReject = reject;
     });
     this.readOps.setFileListReadyPromise(fileListReadyPromise);
 
@@ -303,7 +300,6 @@ export class VeryfrontFSAdapter implements FSAdapter {
 
       this.fileListReadyResolve?.();
       this.fileListReadyResolve = null;
-      this.fileListReadyReject = null;
 
       logger.debug("Fetched files during initialization", {
         cacheKey,
@@ -357,9 +353,9 @@ export class VeryfrontFSAdapter implements FSAdapter {
         this.wsManager.connect(projectId);
       }
     } catch (error) {
-      this.fileListReadyReject?.(error instanceof Error ? error : new Error(String(error)));
+      // Resolve (not reject) to avoid an unhandled-rejection crash in Deno when no lookup() is awaiting.
+      this.fileListReadyResolve?.();
       this.fileListReadyResolve = null;
-      this.fileListReadyReject = null;
       throw error;
     }
   }