zigrix 0.1.1 → 0.2.1

package/README.md

@@ -150,7 +150,7 @@ zigrix reset state --yes
 2. seeds rule files from bundled templates
 3. ensures `zigrix` is reachable from the runtime-visible PATH
 4. detects OpenClaw and imports agents from `openclaw.json`
-5. registers bundled `skills/zigrix-*` into `~/.openclaw/skills/`
+5. registers bundled OpenClaw skills into `~/.openclaw/skills/` (including `oz` and the `zigrix-*` packs)
 6. leaves the environment ready for agent-led orchestration
 
 ---
@@ -161,9 +161,17 @@ When OpenClaw is present, Zigrix is optimized for this model:
 
 - import agent definitions and normalize roles
 - establish orchestrator ownership for task execution
-- register Zigrix skill packs for agent readiness checks
+- register bundled OpenClaw skills for agent readiness checks
+- expose `/oz` as the public Zigrix chat entrypoint after onboarding
 - keep CLI reachability stable for OpenClaw runtime
 
+After `zigrix onboard`, the expected chat-side entrypoints are:
+- `/oz fix the auth flow`
+- `이거 맡겨`
+- `route this through Zigrix`
+
+`/oz` is force-delegate. Natural-language delegation is judged semantically by the installed skill and should enter the standard Zigrix chain (`zigrix task dispatch` → orchestrator spawn) instead of falling back to direct execution.
+
 Read the full integration contract in [docs/openclaw-integration.md](docs/openclaw-integration.md).
 
 ---

package/dist/config/defaults.d.ts

@@ -41,6 +41,10 @@ export declare function buildDefaultConfig(baseDir?: string): {
                 readonly requiredRoles: readonly ["orchestrator", "qa", "security"];
                 readonly optionalRoles: readonly ["frontend", "backend", "system"];
             };
+            readonly large: {
+                readonly requiredRoles: readonly ["orchestrator", "qa", "security", "system"];
+                readonly optionalRoles: readonly ["frontend", "backend"];
+            };
         };
         readonly completion: {
             readonly requireQa: true;
@@ -111,6 +115,10 @@ export declare const defaultConfig: {
                 readonly requiredRoles: readonly ["orchestrator", "qa", "security"];
                 readonly optionalRoles: readonly ["frontend", "backend", "system"];
             };
+            readonly large: {
+                readonly requiredRoles: readonly ["orchestrator", "qa", "security", "system"];
+                readonly optionalRoles: readonly ["frontend", "backend"];
+            };
         };
         readonly completion: {
             readonly requireQa: true;

package/dist/config/defaults.js

@@ -51,7 +51,14 @@ export function buildDefaultConfig(baseDir = resolveCanonicalConfigHome()) {
             scales: {
                 simple: { requiredRoles: ['orchestrator'], optionalRoles: ['qa'] },
                 normal: { requiredRoles: ['orchestrator', 'qa'], optionalRoles: ['frontend', 'backend'] },
-                risky: { requiredRoles: ['orchestrator', 'qa', 'security'], optionalRoles: ['frontend', 'backend', 'system'] },
+                risky: {
+                    requiredRoles: ['orchestrator', 'qa', 'security'],
+                    optionalRoles: ['frontend', 'backend', 'system'],
+                },
+                large: {
+                    requiredRoles: ['orchestrator', 'qa', 'security', 'system'],
+                    optionalRoles: ['frontend', 'backend'],
+                },
             },
             completion: {
                 requireQa: true,

package/dist/config/schema.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+export declare const STANDARD_SCALES: readonly ["simple", "normal", "risky", "large"];
 export declare const zigrixConfigSchema: z.ZodObject<{
     paths: z.ZodObject<{
         baseDir: z.ZodString;
@@ -144,9 +145,120 @@ export declare const zigrixConfigJsonSchema: {
         };
         readonly agents: {
             readonly type: "object";
+            readonly required: readonly ["registry", "orchestration"];
+            readonly properties: {
+                readonly registry: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "object";
+                        readonly required: readonly ["label", "role", "runtime"];
+                        readonly properties: {
+                            readonly label: {
+                                readonly type: "string";
+                            };
+                            readonly role: {
+                                readonly type: "string";
+                                readonly enum: readonly ["orchestrator", "qa", "security", "frontend", "backend", "system"];
+                            };
+                            readonly runtime: {
+                                readonly type: "string";
+                            };
+                            readonly enabled: {
+                                readonly type: "boolean";
+                            };
+                            readonly metadata: {
+                                readonly type: "object";
+                            };
+                        };
+                        readonly additionalProperties: true;
+                    };
+                };
+                readonly orchestration: {
+                    readonly type: "object";
+                    readonly required: readonly ["participants", "excluded", "orchestratorId"];
+                    readonly properties: {
+                        readonly participants: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly excluded: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly orchestratorId: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
         };
         readonly rules: {
             readonly type: "object";
+            readonly required: readonly ["scales", "completion", "stale"];
+            readonly properties: {
+                readonly scales: {
+                    readonly type: "object";
+                    readonly required: readonly ["simple", "normal", "risky", "large"];
+                    readonly properties: {
+                        [k: string]: {
+                            type: string;
+                            required: string[];
+                            properties: {
+                                requiredRoles: {
+                                    type: string;
+                                    items: {
+                                        type: string;
+                                        enum: ("orchestrator" | "qa" | "security" | "frontend" | "backend" | "system")[];
+                                    };
+                                };
+                                optionalRoles: {
+                                    type: string;
+                                    items: {
+                                        type: string;
+                                        enum: ("orchestrator" | "qa" | "security" | "frontend" | "backend" | "system")[];
+                                    };
+                                };
+                            };
+                            additionalProperties: boolean;
+                        };
+                    };
+                    readonly additionalProperties: true;
+                };
+                readonly completion: {
+                    readonly type: "object";
+                    readonly required: readonly ["requireQa", "requireEvidence", "requireUserReport"];
+                    readonly properties: {
+                        readonly requireQa: {
+                            readonly type: "boolean";
+                        };
+                        readonly requireEvidence: {
+                            readonly type: "boolean";
+                        };
+                        readonly requireUserReport: {
+                            readonly type: "boolean";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+                readonly stale: {
+                    readonly type: "object";
+                    readonly required: readonly ["defaultHours"];
+                    readonly properties: {
+                        readonly defaultHours: {
+                            readonly type: "number";
+                            readonly exclusiveMinimum: 0;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly additionalProperties: false;
         };
         readonly templates: {
             readonly type: "object";

package/dist/config/schema.js

@@ -1,8 +1,13 @@
+import path from 'node:path';
 import { z } from 'zod';
 import { STANDARD_AGENT_ROLES, normalizeAgentRole } from '../agents/roles.js';
 const pathSchema = z.string().min(1);
+export const STANDARD_SCALES = ['simple', 'normal', 'risky', 'large'];
 const standardRoleSchema = z.enum(STANDARD_AGENT_ROLES);
-const roleSchema = z.string().min(1).transform((value, ctx) => {
+const roleSchema = z
+    .string()
+    .min(1)
+    .transform((value, ctx) => {
     const normalized = normalizeAgentRole(value);
     if (!normalized) {
         ctx.addIssue({
@@ -12,7 +17,8 @@ const roleSchema = z.string().min(1).transform((value, ctx) => {
         return z.NEVER;
     }
     return normalized;
-}).pipe(standardRoleSchema);
+})
+    .pipe(standardRoleSchema);
 const agentSchema = z.object({
     label: z.string().min(1),
     role: roleSchema,
@@ -27,7 +33,8 @@ const templateSchema = z.object({
     body: z.string().min(1),
 });
 export const zigrixConfigSchema = z.object({
-    paths: z.object({
+    paths: z
+        .object({
         baseDir: pathSchema,
         tasksDir: pathSchema,
         evidenceDir: pathSchema,
@@ -36,18 +43,58 @@ export const zigrixConfigSchema = z.object({
         indexFile: pathSchema,
         runsDir: pathSchema,
         rulesDir: pathSchema,
+    })
+        .superRefine((value, ctx) => {
+        const directoryEntries = [
+            ['tasksDir', value.tasksDir],
+            ['evidenceDir', value.evidenceDir],
+            ['promptsDir', value.promptsDir],
+            ['runsDir', value.runsDir],
+            ['rulesDir', value.rulesDir],
+        ];
+        const fileEntries = [
+            ['eventsFile', value.eventsFile],
+            ['indexFile', value.indexFile],
+        ];
+        const seen = new Map();
+        for (const [name, rawPath] of [...directoryEntries, ...fileEntries]) {
+            const normalized = path.resolve(rawPath);
+            const existing = seen.get(normalized);
+            if (existing) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `${name} collides with ${existing}`,
+                    path: [name],
+                });
+                continue;
+            }
+            seen.set(normalized, name);
+        }
+        const directoryPaths = new Set(directoryEntries.map(([, rawPath]) => path.resolve(rawPath)));
+        for (const [name, rawPath] of fileEntries) {
+            const normalized = path.resolve(rawPath);
+            if (directoryPaths.has(normalized)) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `${name} must not resolve to a runtime directory path`,
+                    path: [name],
+                });
+            }
+        }
     }),
     workspace: z.object({
         projectsBaseDir: z.string().default(''),
     }),
-    agents: z.object({
+    agents: z
+        .object({
         registry: z.record(z.string(), agentSchema),
         orchestration: z.object({
             participants: z.array(z.string()),
             excluded: z.array(z.string()),
             orchestratorId: z.string().min(1),
         }),
-    }).superRefine((value, ctx) => {
+    })
+        .superRefine((value, ctx) => {
         const overlap = value.orchestration.participants.filter((item) => value.orchestration.excluded.includes(item));
         for (const agentId of overlap) {
             ctx.addIssue({
@@ -87,6 +134,22 @@ export const zigrixConfigSchema = z.object({
                 path: ['orchestration', 'orchestratorId'],
             });
         }
+        if (hasOrchestratorInRegistry && value.registry[orchestratorId]?.enabled === false) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `orchestratorId '${orchestratorId}' must reference an enabled agent`,
+                path: ['orchestration', 'orchestratorId'],
+            });
+        }
+        if (value.orchestration.participants.length > 0 &&
+            hasOrchestratorInRegistry &&
+            !value.orchestration.participants.includes(orchestratorId)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `orchestratorId '${orchestratorId}' must be included in participants when participant mode is active`,
+                path: ['orchestration', 'participants'],
+            });
+        }
         if (value.orchestration.excluded.includes(orchestratorId)) {
             ctx.addIssue({
                 code: z.ZodIssueCode.custom,
@@ -96,10 +159,32 @@ export const zigrixConfigSchema = z.object({
         }
     }),
     rules: z.object({
-        scales: z.record(z.string(), z.object({
+        scales: z
+            .record(z.string(), z.object({
             requiredRoles: z.array(roleSchema),
             optionalRoles: z.array(roleSchema),
-        })),
+        }))
+            .superRefine((value, ctx) => {
+            for (const scale of STANDARD_SCALES) {
+                if (!(scale in value)) {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: `rules.scales must define '${scale}'`,
+                        path: [scale],
+                    });
+                }
+            }
+            for (const [scale, policy] of Object.entries(value)) {
+                const overlap = policy.requiredRoles.filter((role) => policy.optionalRoles.includes(role));
+                for (const role of overlap) {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: `scale '${scale}' cannot list role '${role}' as both required and optional`,
+                        path: [scale],
+                    });
+                }
+            }
+        }),
         completion: z.object({
             requireQa: z.boolean(),
             requireEvidence: z.boolean(),
@@ -113,11 +198,13 @@ export const zigrixConfigSchema = z.object({
         workerPrompt: templateSchema,
         finalReport: templateSchema,
     }),
-    openclaw: z.object({
+    openclaw: z
+        .object({
         home: z.string().default(''),
         binPath: z.string().nullable().default(null),
         gatewayUrl: z.string().default(''),
-    }).default({ home: '', binPath: null, gatewayUrl: '' }),
+    })
+        .default({ home: '', binPath: null, gatewayUrl: '' }),
     runtime: z.object({
         outputMode: z.enum(['text', 'json']),
         jsonIndent: z.number().int().min(0).max(8),
@@ -131,7 +218,16 @@ export const zigrixConfigJsonSchema = {
     properties: {
         paths: {
             type: 'object',
-            required: ['baseDir', 'tasksDir', 'evidenceDir', 'promptsDir', 'eventsFile', 'indexFile', 'runsDir', 'rulesDir'],
+            required: [
+                'baseDir',
+                'tasksDir',
+                'evidenceDir',
+                'promptsDir',
+                'eventsFile',
+                'indexFile',
+                'runsDir',
+                'rulesDir',
+            ],
             properties: {
                 baseDir: { type: 'string' },
                 tasksDir: { type: 'string' },
@@ -151,8 +247,86 @@ export const zigrixConfigJsonSchema = {
             },
             additionalProperties: false,
         },
-        agents: { type: 'object' },
-        rules: { type: 'object' },
+        agents: {
+            type: 'object',
+            required: ['registry', 'orchestration'],
+            properties: {
+                registry: {
+                    type: 'object',
+                    additionalProperties: {
+                        type: 'object',
+                        required: ['label', 'role', 'runtime'],
+                        properties: {
+                            label: { type: 'string' },
+                            role: { type: 'string', enum: [...STANDARD_AGENT_ROLES] },
+                            runtime: { type: 'string' },
+                            enabled: { type: 'boolean' },
+                            metadata: { type: 'object' },
+                        },
+                        additionalProperties: true,
+                    },
+                },
+                orchestration: {
+                    type: 'object',
+                    required: ['participants', 'excluded', 'orchestratorId'],
+                    properties: {
+                        participants: { type: 'array', items: { type: 'string' } },
+                        excluded: { type: 'array', items: { type: 'string' } },
+                        orchestratorId: { type: 'string' },
+                    },
+                    additionalProperties: false,
+                },
+            },
+            additionalProperties: false,
+        },
+        rules: {
+            type: 'object',
+            required: ['scales', 'completion', 'stale'],
+            properties: {
+                scales: {
+                    type: 'object',
+                    required: [...STANDARD_SCALES],
+                    properties: Object.fromEntries(STANDARD_SCALES.map((scale) => [
+                        scale,
+                        {
+                            type: 'object',
+                            required: ['requiredRoles', 'optionalRoles'],
+                            properties: {
+                                requiredRoles: {
+                                    type: 'array',
+                                    items: { type: 'string', enum: [...STANDARD_AGENT_ROLES] },
+                                },
+                                optionalRoles: {
+                                    type: 'array',
+                                    items: { type: 'string', enum: [...STANDARD_AGENT_ROLES] },
+                                },
+                            },
+                            additionalProperties: false,
+                        },
+                    ])),
+                    additionalProperties: true,
+                },
+                completion: {
+                    type: 'object',
+                    required: ['requireQa', 'requireEvidence', 'requireUserReport'],
+                    properties: {
+                        requireQa: { type: 'boolean' },
+                        requireEvidence: { type: 'boolean' },
+                        requireUserReport: { type: 'boolean' },
+                    },
+                    additionalProperties: false,
+                },
+                stale: {
+                    type: 'object',
+                    required: ['defaultHours'],
+                    properties: {
+                        defaultHours: { type: 'number', exclusiveMinimum: 0 },
+                    },
+                    additionalProperties: false,
+                },
+            },
+            additionalProperties: false,
+        },
         templates: { type: 'object' },
         openclaw: {
             type: 'object',

package/dist/dashboard/.next/BUILD_ID

@@ -1 +1 @@
-iKGx5hWe1zbwJZWchF9kg
+dOjvoQUj-mqwJ8kKG4peU

package/dist/dashboard/.next/app-build-manifest.json

@@ -3,14 +3,14 @@
     "/_not-found/page": [
       "static/chunks/webpack-1c485544eee88ef7.js",
       "static/chunks/4bd1b696-c023c6e3521b1417.js",
-      "static/chunks/255-ebd51be49873d76c.js",
+      "static/chunks/255-4f212684648fcab9.js",
       "static/chunks/main-app-458501fc143f8dcb.js",
       "static/chunks/app/_not-found/page-1ec508643ed76f3b.js"
     ],
     "/layout": [
       "static/chunks/webpack-1c485544eee88ef7.js",
       "static/chunks/4bd1b696-c023c6e3521b1417.js",
-      "static/chunks/255-ebd51be49873d76c.js",
+      "static/chunks/255-4f212684648fcab9.js",
       "static/chunks/main-app-458501fc143f8dcb.js",
       "static/css/9f7ffdac282b0450.css",
       "static/chunks/app/layout-96206a34ff37a783.js"
@@ -18,86 +18,86 @@
     "/api/auth/logout/route": [
       "static/chunks/webpack-1c485544eee88ef7.js",
       "static/chunks/4bd1b696-c023c6e3521b1417.js",
-      "static/chunks/255-ebd51be49873d76c.js",
+      "static/chunks/255-4f212684648fcab9.js",
       "static/chunks/main-app-458501fc143f8dcb.js",
       "static/chunks/app/api/auth/logout/route-aaf047a494f0055f.js"
     ],
     "/api/auth/session/route": [
       "static/chunks/webpack-1c485544eee88ef7.js",
       "static/chunks/4bd1b696-c023c6e3521b1417.js",
-      "static/chunks/255-ebd51be49873d76c.js",
+      "static/chunks/255-4f212684648fcab9.js",
       "static/chunks/main-app-458501fc143f8dcb.js",
       "static/chunks/app/api/auth/session/route-aaf047a494f0055f.js"
     ],
-    "/api/auth/setup/route": [
+    "/api/auth/login/route": [
       "static/chunks/webpack-1c485544eee88ef7.js",
       "static/chunks/4bd1b696-c023c6e3521b1417.js",
-      "static/chunks/255-ebd51be49873d76c.js",
+      "static/chunks/255-4f212684648fcab9.js",
       "static/chunks/main-app-458501fc143f8dcb.js",
-      "static/chunks/app/api/auth/setup/route-aaf047a494f0055f.js"
+      "static/chunks/app/api/auth/login/route-aaf047a494f0055f.js"
     ],
-    "/api/auth/login/route": [
+    "/api/auth/setup/route": [
       "static/chunks/webpack-1c485544eee88ef7.js",
       "static/chunks/4bd1b696-c023c6e3521b1417.js",
-      "static/chunks/255-ebd51be49873d76c.js",
+      "static/chunks/255-4f212684648fcab9.js",
       "static/chunks/main-app-458501fc143f8dcb.js",
-      "static/chunks/app/api/auth/login/route-aaf047a494f0055f.js"
+      "static/chunks/app/api/auth/setup/route-aaf047a494f0055f.js"
     ],
     "/api/overview/route": [
       "static/chunks/webpack-1c485544eee88ef7.js",
       "static/chunks/4bd1b696-c023c6e3521b1417.js",
-      "static/chunks/255-ebd51be49873d76c.js",
+      "static/chunks/255-4f212684648fcab9.js",
       "static/chunks/main-app-458501fc143f8dcb.js",
       "static/chunks/app/api/overview/route-aaf047a494f0055f.js"
     ],
-    "/api/tasks/[taskId]/cancel/route": [
+    "/api/tasks/[taskId]/route": [
       "static/chunks/webpack-1c485544eee88ef7.js",
       "static/chunks/4bd1b696-c023c6e3521b1417.js",
-      "static/chunks/255-ebd51be49873d76c.js",
+      "static/chunks/255-4f212684648fcab9.js",
       "static/chunks/main-app-458501fc143f8dcb.js",
-      "static/chunks/app/api/tasks/[taskId]/cancel/route-aaf047a494f0055f.js"
+      "static/chunks/app/api/tasks/[taskId]/route-aaf047a494f0055f.js"
     ],
-    "/api/tasks/[taskId]/conversation/route": [
+    "/api/tasks/[taskId]/cancel/route": [
       "static/chunks/webpack-1c485544eee88ef7.js",
       "static/chunks/4bd1b696-c023c6e3521b1417.js",
-      "static/chunks/255-ebd51be49873d76c.js",
+      "static/chunks/255-4f212684648fcab9.js",
       "static/chunks/main-app-458501fc143f8dcb.js",
-      "static/chunks/app/api/tasks/[taskId]/conversation/route-aaf047a494f0055f.js"
+      "static/chunks/app/api/tasks/[taskId]/cancel/route-aaf047a494f0055f.js"
     ],
-    "/api/tasks/[taskId]/route": [
+    "/api/tasks/[taskId]/conversation/route": [
       "static/chunks/webpack-1c485544eee88ef7.js",
       "static/chunks/4bd1b696-c023c6e3521b1417.js",
-      "static/chunks/255-ebd51be49873d76c.js",
+      "static/chunks/255-4f212684648fcab9.js",
       "static/chunks/main-app-458501fc143f8dcb.js",
-      "static/chunks/app/api/tasks/[taskId]/route-aaf047a494f0055f.js"
+      "static/chunks/app/api/tasks/[taskId]/conversation/route-aaf047a494f0055f.js"
     ],
     "/api/stream/route": [
       "static/chunks/webpack-1c485544eee88ef7.js",
       "static/chunks/4bd1b696-c023c6e3521b1417.js",
-      "static/chunks/255-ebd51be49873d76c.js",
+      "static/chunks/255-4f212684648fcab9.js",
       "static/chunks/main-app-458501fc143f8dcb.js",
       "static/chunks/app/api/stream/route-aaf047a494f0055f.js"
     ],
-    "/setup/page": [
+    "/login/page": [
       "static/chunks/webpack-1c485544eee88ef7.js",
       "static/chunks/4bd1b696-c023c6e3521b1417.js",
-      "static/chunks/255-ebd51be49873d76c.js",
+      "static/chunks/255-4f212684648fcab9.js",
       "static/chunks/main-app-458501fc143f8dcb.js",
       "static/css/1f406f685b1e941e.css",
-      "static/chunks/app/setup/page-a01ab6e2460293c3.js"
+      "static/chunks/app/login/page-f627cfc7a91a6d34.js"
     ],
-    "/login/page": [
+    "/setup/page": [
       "static/chunks/webpack-1c485544eee88ef7.js",
       "static/chunks/4bd1b696-c023c6e3521b1417.js",
-      "static/chunks/255-ebd51be49873d76c.js",
+      "static/chunks/255-4f212684648fcab9.js",
       "static/chunks/main-app-458501fc143f8dcb.js",
       "static/css/1f406f685b1e941e.css",
-      "static/chunks/app/login/page-f627cfc7a91a6d34.js"
+      "static/chunks/app/setup/page-a01ab6e2460293c3.js"
     ],
     "/page": [
       "static/chunks/webpack-1c485544eee88ef7.js",
       "static/chunks/4bd1b696-c023c6e3521b1417.js",
-      "static/chunks/255-ebd51be49873d76c.js",
+      "static/chunks/255-4f212684648fcab9.js",
       "static/chunks/main-app-458501fc143f8dcb.js",
       "static/css/c3a7306cb2ba3f6c.css",
       "static/chunks/856-4671c40140d5540a.js",

package/dist/dashboard/.next/app-path-routes-manifest.json

@@ -2,14 +2,14 @@
   "/_not-found/page": "/_not-found",
   "/api/auth/logout/route": "/api/auth/logout",
   "/api/auth/session/route": "/api/auth/session",
-  "/api/auth/setup/route": "/api/auth/setup",
   "/api/auth/login/route": "/api/auth/login",
+  "/api/auth/setup/route": "/api/auth/setup",
   "/api/overview/route": "/api/overview",
+  "/api/tasks/[taskId]/route": "/api/tasks/[taskId]",
   "/api/tasks/[taskId]/cancel/route": "/api/tasks/[taskId]/cancel",
   "/api/tasks/[taskId]/conversation/route": "/api/tasks/[taskId]/conversation",
-  "/api/tasks/[taskId]/route": "/api/tasks/[taskId]",
   "/api/stream/route": "/api/stream",
-  "/setup/page": "/setup",
   "/login/page": "/login",
+  "/setup/page": "/setup",
   "/page": "/"
 }

package/dist/dashboard/.next/build-manifest.json

@@ -5,13 +5,13 @@
   "devFiles": [],
   "ampDevFiles": [],
   "lowPriorityFiles": [
-    "static/iKGx5hWe1zbwJZWchF9kg/_buildManifest.js",
-    "static/iKGx5hWe1zbwJZWchF9kg/_ssgManifest.js"
+    "static/dOjvoQUj-mqwJ8kKG4peU/_buildManifest.js",
+    "static/dOjvoQUj-mqwJ8kKG4peU/_ssgManifest.js"
   ],
   "rootMainFiles": [
     "static/chunks/webpack-1c485544eee88ef7.js",
     "static/chunks/4bd1b696-c023c6e3521b1417.js",
-    "static/chunks/255-ebd51be49873d76c.js",
+    "static/chunks/255-4f212684648fcab9.js",
     "static/chunks/main-app-458501fc143f8dcb.js"
   ],
   "rootMainFilesTree": {},
@@ -19,13 +19,13 @@
     "/_app": [
       "static/chunks/webpack-1c485544eee88ef7.js",
       "static/chunks/framework-de98b93a850cfc71.js",
-      "static/chunks/main-da2d845a416cfa3f.js",
+      "static/chunks/main-cec07dc17fdd452c.js",
       "static/chunks/pages/_app-7d307437aca18ad4.js"
     ],
     "/_error": [
       "static/chunks/webpack-1c485544eee88ef7.js",
       "static/chunks/framework-de98b93a850cfc71.js",
-      "static/chunks/main-da2d845a416cfa3f.js",
+      "static/chunks/main-cec07dc17fdd452c.js",
       "static/chunks/pages/_error-cb2a52f75f2162e2.js"
     ]
   },