zigrix 0.1.0-alpha.8 → 0.1.0

package/dist/config/defaults.js

@@ -1,58 +1,90 @@
 import path from 'node:path';
 import os from 'node:os';
-export const ZIGRIX_HOME = process.env.ZIGRIX_HOME ?? path.join(os.homedir(), '.zigrix');
-export const defaultConfig = {
-    paths: {
-        baseDir: ZIGRIX_HOME,
-        tasksDir: path.join(ZIGRIX_HOME, 'tasks'),
-        evidenceDir: path.join(ZIGRIX_HOME, 'evidence'),
-        promptsDir: path.join(ZIGRIX_HOME, 'prompts'),
-        eventsFile: path.join(ZIGRIX_HOME, 'tasks.jsonl'),
-        indexFile: path.join(ZIGRIX_HOME, 'index.json'),
-        runsDir: path.join(ZIGRIX_HOME, 'runs'),
-        rulesDir: path.join(ZIGRIX_HOME, 'rules'),
-    },
-    workspace: {
-        projectsBaseDir: '',
-    },
-    agents: {
-        registry: {},
-        orchestration: {
-            participants: [],
-            excluded: [],
+export const CONFIG_FILENAME = 'zigrix.config.json';
+export const LEGACY_DEFAULT_GATEWAY_URL = 'http://127.0.0.1:18789';
+export function expandTilde(input) {
+    const homeDir = os.homedir();
+    if (!input)
+        return homeDir;
+    if (input === '~')
+        return homeDir;
+    if (input.startsWith('~/'))
+        return path.join(homeDir, input.slice(2));
+    return input;
+}
+export function resolveAbsolutePath(input) {
+    return path.resolve(expandTilde(input));
+}
+export function resolveCanonicalConfigHome() {
+    return path.join(os.homedir(), '.zigrix');
+}
+export function resolveCanonicalConfigPath() {
+    return path.join(resolveCanonicalConfigHome(), CONFIG_FILENAME);
+}
+export function resolveDefaultWorkspaceDir(baseDir = resolveCanonicalConfigHome()) {
+    return path.join(baseDir, 'workspace');
+}
+export function buildDefaultConfig(baseDir = resolveCanonicalConfigHome()) {
+    return {
+        paths: {
+            baseDir,
+            tasksDir: path.join(baseDir, 'tasks'),
+            evidenceDir: path.join(baseDir, 'evidence'),
+            promptsDir: path.join(baseDir, 'prompts'),
+            eventsFile: path.join(baseDir, 'tasks.jsonl'),
+            indexFile: path.join(baseDir, 'index.json'),
+            runsDir: path.join(baseDir, 'runs'),
+            rulesDir: path.join(baseDir, 'rules'),
         },
-    },
-    rules: {
-        scales: {
-            simple: { requiredRoles: ['orchestrator'], optionalRoles: ['qa'] },
-            normal: { requiredRoles: ['orchestrator', 'qa'], optionalRoles: ['frontend', 'backend'] },
-            risky: { requiredRoles: ['orchestrator', 'qa', 'security'], optionalRoles: ['frontend', 'backend', 'infra'] },
+        workspace: {
+            projectsBaseDir: resolveDefaultWorkspaceDir(baseDir),
         },
-        completion: {
-            requireQa: true,
-            requireEvidence: true,
-            requireUserReport: true,
+        agents: {
+            registry: {},
+            orchestration: {
+                participants: [],
+                excluded: [],
+                orchestratorId: 'orchestrator',
+            },
         },
-        stale: {
-            defaultHours: 24,
+        rules: {
+            scales: {
+                simple: { requiredRoles: ['orchestrator'], optionalRoles: ['qa'] },
+                normal: { requiredRoles: ['orchestrator', 'qa'], optionalRoles: ['frontend', 'backend'] },
+                risky: { requiredRoles: ['orchestrator', 'qa', 'security'], optionalRoles: ['frontend', 'backend', 'system'] },
+            },
+            completion: {
+                requireQa: true,
+                requireEvidence: true,
+                requireUserReport: true,
+            },
+            stale: {
+                defaultHours: 24,
+            },
         },
-    },
-    templates: {
-        workerPrompt: {
-            format: 'markdown',
-            version: 1,
-            placeholders: ['taskId', 'title', 'scale', 'agentId', 'description'],
-            body: '## Worker Assignment: {{taskId}}\n- title: {{title}}\n- scale: {{scale}}\n- agent: {{agentId}}\n- description: {{description}}',
+        templates: {
+            workerPrompt: {
+                format: 'markdown',
+                version: 2,
+                placeholders: ['taskId', 'title', 'scale', 'agentId', 'description'],
+                body: '## Worker Assignment: {{taskId}}\n- title: {{title}}\n- scale: {{scale}}\n- agent: {{agentId}}\n- description: {{description}}\n\n### Completion\n작업 완료 후 반드시 증적을 먼저 수집하라:\n```bash\nzigrix evidence collect --task-id {{taskId}} --agent-id {{agentId}} --summary "<결과 요약>"\n```\n⚠️ 증적 없이 완료하면 finalize에서 incomplete 판정된다.',
+            },
+            finalReport: {
+                format: 'markdown',
+                version: 1,
+                placeholders: ['taskId', 'title', 'status', 'summary'],
+                body: '## Final Report: {{taskId}}\n- title: {{title}}\n- status: {{status}}\n- summary: {{summary}}',
+            },
         },
-        finalReport: {
-            format: 'markdown',
-            version: 1,
-            placeholders: ['taskId', 'title', 'status', 'summary'],
-            body: '## Final Report: {{taskId}}\n- title: {{title}}\n- status: {{status}}\n- summary: {{summary}}',
+        openclaw: {
+            home: '',
+            binPath: null,
+            gatewayUrl: '',
         },
-    },
-    runtime: {
-        outputMode: 'text',
-        jsonIndent: 2,
-    },
-};
+        runtime: {
+            outputMode: 'text',
+            jsonIndent: 2,
+        },
+    };
+}
+export const defaultConfig = buildDefaultConfig();

package/dist/config/load.d.ts

@@ -1,13 +1,15 @@
+import { CONFIG_FILENAME } from './defaults.js';
 import { type ZigrixConfig } from './schema.js';
 export type LoadedConfig = {
     config: ZigrixConfig;
-    configPath: string | null;
+    configPath: string;
     baseDir: string;
 };
+export declare function normalizeConfig(input: ZigrixConfig): ZigrixConfig;
 export declare function loadConfig(options?: {
-    baseDir?: string;
     configPath?: string;
 }): LoadedConfig;
 export declare function writeConfigFile(targetPath: string, config: ZigrixConfig): string;
-export declare function writeDefaultConfig(baseDir?: string, force?: boolean): string;
+export declare function writeDefaultConfig(force?: boolean): string;
 export declare function getConfigValue(config: ZigrixConfig, dottedPath?: string): unknown;
+export { CONFIG_FILENAME };

package/dist/config/load.js

@@ -1,14 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
-import YAML from 'yaml';
-import { defaultConfig, ZIGRIX_HOME } from './defaults.js';
+import { buildDefaultConfig, CONFIG_FILENAME, expandTilde, resolveAbsolutePath, resolveCanonicalConfigHome, resolveCanonicalConfigPath, resolveDefaultWorkspaceDir, } from './defaults.js';
 import { zigrixConfigSchema } from './schema.js';
-const CONFIG_CANDIDATES = [
-    'zigrix.config.json',
-    'zigrix.config.yaml',
-    'zigrix.config.yml',
-];
 function isObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -30,22 +24,60 @@ function deepMerge(base, override) {
 }
 function parseConfigFile(filePath) {
     const raw = fs.readFileSync(filePath, 'utf8');
-    if (filePath.endsWith('.yaml') || filePath.endsWith('.yml')) {
-        return YAML.parse(raw);
-    }
     return JSON.parse(raw);
 }
-function resolveConfigPath(baseDir, explicitPath) {
+function resolveConfigPath(explicitPath) {
     if (explicitPath) {
-        return path.resolve(explicitPath);
+        return resolveAbsolutePath(explicitPath);
+    }
+    return resolveCanonicalConfigPath();
+}
+function resolvePathLike(value, baseDir, fallback) {
+    if (typeof value !== 'string')
+        return fallback;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return fallback;
+    const expanded = expandTilde(trimmed);
+    if (path.isAbsolute(expanded))
+        return path.resolve(expanded);
+    return path.resolve(baseDir, expanded);
+}
+function normalizeConfigPaths(config) {
+    const copy = structuredClone(config);
+    const configHome = resolveCanonicalConfigHome();
+    const resolvedBaseDir = resolvePathLike(copy.paths.baseDir, configHome, configHome);
+    copy.paths.baseDir = resolvedBaseDir;
+    copy.paths.tasksDir = resolvePathLike(copy.paths.tasksDir, resolvedBaseDir, path.join(resolvedBaseDir, 'tasks'));
+    copy.paths.evidenceDir = resolvePathLike(copy.paths.evidenceDir, resolvedBaseDir, path.join(resolvedBaseDir, 'evidence'));
+    copy.paths.promptsDir = resolvePathLike(copy.paths.promptsDir, resolvedBaseDir, path.join(resolvedBaseDir, 'prompts'));
+    copy.paths.eventsFile = resolvePathLike(copy.paths.eventsFile, resolvedBaseDir, path.join(resolvedBaseDir, 'tasks.jsonl'));
+    copy.paths.indexFile = resolvePathLike(copy.paths.indexFile, resolvedBaseDir, path.join(resolvedBaseDir, 'index.json'));
+    copy.paths.runsDir = resolvePathLike(copy.paths.runsDir, resolvedBaseDir, path.join(resolvedBaseDir, 'runs'));
+    copy.paths.rulesDir = resolvePathLike(copy.paths.rulesDir, resolvedBaseDir, path.join(resolvedBaseDir, 'rules'));
+    const configuredWorkspace = typeof copy.workspace.projectsBaseDir === 'string'
+        ? copy.workspace.projectsBaseDir.trim()
+        : '';
+    copy.workspace.projectsBaseDir = configuredWorkspace.length > 0
+        ? resolvePathLike(configuredWorkspace, resolvedBaseDir, resolveDefaultWorkspaceDir(resolvedBaseDir))
+        : resolveDefaultWorkspaceDir(resolvedBaseDir);
+    if (typeof copy.openclaw.home === 'string' && copy.openclaw.home.trim().length > 0) {
+        copy.openclaw.home = resolveAbsolutePath(copy.openclaw.home);
     }
-    for (const candidate of CONFIG_CANDIDATES) {
-        const fullPath = path.join(baseDir, candidate);
-        if (fs.existsSync(fullPath)) {
-            return fullPath;
+    if (typeof copy.openclaw.binPath === 'string' && copy.openclaw.binPath.trim().length > 0) {
+        copy.openclaw.binPath = resolveAbsolutePath(copy.openclaw.binPath);
+    }
+    return copy;
+}
+function resolveBaseDirHint(parsed, fallback) {
+    if (isObject(parsed) && isObject(parsed.paths) && typeof parsed.paths.baseDir === 'string') {
+        const configured = parsed.paths.baseDir.trim();
+        if (configured.length > 0) {
+            const expanded = expandTilde(configured);
+            return path.isAbsolute(expanded) ? path.resolve(expanded) : path.resolve(fallback, expanded);
         }
     }
-    return null;
+    return fallback;
 }
 function applyEnvOverrides(config) {
     const copy = structuredClone(config);
@@ -60,29 +92,35 @@ function applyEnvOverrides(config) {
     }
     return copy;
 }
+export function normalizeConfig(input) {
+    const normalized = normalizeConfigPaths(input);
+    return zigrixConfigSchema.parse(normalized);
+}
 export function loadConfig(options) {
-    const baseDir = path.resolve(options?.baseDir ?? ZIGRIX_HOME);
-    const configPath = resolveConfigPath(baseDir, options?.configPath);
-    const parsed = configPath ? parseConfigFile(configPath) : {};
-    const merged = deepMerge(structuredClone(defaultConfig), parsed);
+    const configPath = resolveConfigPath(options?.configPath);
+    const parsed = fs.existsSync(configPath) ? parseConfigFile(configPath) : {};
+    const defaultBaseDir = resolveBaseDirHint(parsed, resolveCanonicalConfigHome());
+    const defaults = buildDefaultConfig(defaultBaseDir);
+    const merged = deepMerge(structuredClone(defaults), parsed);
     const withEnv = applyEnvOverrides(merged);
-    const result = zigrixConfigSchema.parse(withEnv);
-    return { config: result, configPath, baseDir };
+    const result = normalizeConfig(withEnv);
+    return { config: result, configPath, baseDir: result.paths.baseDir };
 }
 export function writeConfigFile(targetPath, config) {
-    const resolvedPath = path.resolve(targetPath);
+    const resolvedPath = resolveAbsolutePath(targetPath);
     fs.mkdirSync(path.dirname(resolvedPath), { recursive: true });
-    fs.writeFileSync(resolvedPath, `${JSON.stringify(zigrixConfigSchema.parse(config), null, 2)}\n`, 'utf8');
+    const normalized = normalizeConfig(config);
+    fs.writeFileSync(resolvedPath, `${JSON.stringify(normalized, null, 2)}\n`, 'utf8');
     return resolvedPath;
 }
-export function writeDefaultConfig(baseDir, force = false) {
-    const resolvedBase = path.resolve(baseDir ?? ZIGRIX_HOME);
-    const targetPath = path.join(resolvedBase, 'zigrix.config.json');
+export function writeDefaultConfig(force = false) {
+    const configHome = resolveCanonicalConfigHome();
+    const targetPath = resolveCanonicalConfigPath();
     if (fs.existsSync(targetPath) && !force) {
         throw new Error(`config already exists: ${targetPath}`);
     }
-    fs.mkdirSync(resolvedBase, { recursive: true });
-    return writeConfigFile(targetPath, structuredClone(defaultConfig));
+    fs.mkdirSync(configHome, { recursive: true });
+    return writeConfigFile(targetPath, buildDefaultConfig(configHome));
 }
 export function getConfigValue(config, dottedPath) {
     if (!dottedPath)
@@ -94,3 +132,4 @@ export function getConfigValue(config, dottedPath) {
         return undefined;
     }, config);
 }
+export { CONFIG_FILENAME };

package/dist/config/schema.d.ts

@@ -16,7 +16,14 @@ export declare const zigrixConfigSchema: z.ZodObject<{
     agents: z.ZodObject<{
         registry: z.ZodRecord<z.ZodString, z.ZodObject<{
             label: z.ZodString;
-            role: z.ZodString;
+            role: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<"orchestrator" | "qa" | "security" | "frontend" | "backend" | "system", string>>, z.ZodEnum<{
+                orchestrator: "orchestrator";
+                qa: "qa";
+                security: "security";
+                frontend: "frontend";
+                backend: "backend";
+                system: "system";
+            }>>;
             runtime: z.ZodString;
             enabled: z.ZodDefault<z.ZodBoolean>;
             metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -24,12 +31,27 @@ export declare const zigrixConfigSchema: z.ZodObject<{
         orchestration: z.ZodObject<{
             participants: z.ZodArray<z.ZodString>;
             excluded: z.ZodArray<z.ZodString>;
+            orchestratorId: z.ZodString;
         }, z.core.$strip>;
     }, z.core.$strip>;
     rules: z.ZodObject<{
         scales: z.ZodRecord<z.ZodString, z.ZodObject<{
-            requiredRoles: z.ZodArray<z.ZodString>;
-            optionalRoles: z.ZodArray<z.ZodString>;
+            requiredRoles: z.ZodArray<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<"orchestrator" | "qa" | "security" | "frontend" | "backend" | "system", string>>, z.ZodEnum<{
+                orchestrator: "orchestrator";
+                qa: "qa";
+                security: "security";
+                frontend: "frontend";
+                backend: "backend";
+                system: "system";
+            }>>>;
+            optionalRoles: z.ZodArray<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<"orchestrator" | "qa" | "security" | "frontend" | "backend" | "system", string>>, z.ZodEnum<{
+                orchestrator: "orchestrator";
+                qa: "qa";
+                security: "security";
+                frontend: "frontend";
+                backend: "backend";
+                system: "system";
+            }>>>;
         }, z.core.$strip>>;
         completion: z.ZodObject<{
             requireQa: z.ZodBoolean;
@@ -60,6 +82,11 @@ export declare const zigrixConfigSchema: z.ZodObject<{
             body: z.ZodString;
         }, z.core.$strip>;
     }, z.core.$strip>;
+    openclaw: z.ZodDefault<z.ZodObject<{
+        home: z.ZodDefault<z.ZodString>;
+        binPath: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        gatewayUrl: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
     runtime: z.ZodObject<{
         outputMode: z.ZodEnum<{
             text: "text";
@@ -73,7 +100,7 @@ export declare const zigrixConfigJsonSchema: {
     readonly $schema: "https://json-schema.org/draft/2020-12/schema";
     readonly title: "ZigrixConfig";
     readonly type: "object";
-    readonly required: readonly ["paths", "workspace", "agents", "rules", "templates", "runtime"];
+    readonly required: readonly ["paths", "workspace", "agents", "rules", "templates", "openclaw", "runtime"];
     readonly properties: {
         readonly paths: {
             readonly type: "object";
@@ -124,6 +151,21 @@ export declare const zigrixConfigJsonSchema: {
         readonly templates: {
             readonly type: "object";
         };
+        readonly openclaw: {
+            readonly type: "object";
+            readonly properties: {
+                readonly home: {
+                    readonly type: "string";
+                };
+                readonly binPath: {
+                    readonly type: readonly ["string", "null"];
+                };
+                readonly gatewayUrl: {
+                    readonly type: "string";
+                };
+            };
+            readonly additionalProperties: false;
+        };
         readonly runtime: {
             readonly type: "object";
         };

package/dist/config/schema.js

@@ -1,9 +1,21 @@
 import { z } from 'zod';
-const roleSchema = z.string().min(1);
+import { STANDARD_AGENT_ROLES, normalizeAgentRole } from '../agents/roles.js';
 const pathSchema = z.string().min(1);
+const standardRoleSchema = z.enum(STANDARD_AGENT_ROLES);
+const roleSchema = z.string().min(1).transform((value, ctx) => {
+    const normalized = normalizeAgentRole(value);
+    if (!normalized) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `role must be one of: ${STANDARD_AGENT_ROLES.join(', ')}`,
+        });
+        return z.NEVER;
+    }
+    return normalized;
+}).pipe(standardRoleSchema);
 const agentSchema = z.object({
     label: z.string().min(1),
-    role: z.string().min(1),
+    role: roleSchema,
     runtime: z.string().min(1),
     enabled: z.boolean().default(true),
     metadata: z.record(z.string(), z.unknown()).default({}),
@@ -33,6 +45,7 @@ export const zigrixConfigSchema = z.object({
         orchestration: z.object({
             participants: z.array(z.string()),
             excluded: z.array(z.string()),
+            orchestratorId: z.string().min(1),
         }),
     }).superRefine((value, ctx) => {
         const overlap = value.orchestration.participants.filter((item) => value.orchestration.excluded.includes(item));
@@ -62,6 +75,25 @@ export const zigrixConfigSchema = z.object({
                 });
             }
         }
+        // Only validate orchestratorId against registry when agents are registered
+        // During bootstrap (addAgent one-by-one), registry may not yet include the orchestrator
+        const orchestratorId = value.orchestration.orchestratorId;
+        const hasOrchestratorInRegistry = knownAgents.has(orchestratorId);
+        const hasAnyOrchestrator = Object.values(value.registry).some((agent) => agent.role === 'orchestrator');
+        if (hasAnyOrchestrator && !hasOrchestratorInRegistry) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `orchestratorId '${orchestratorId}' must exist in registry`,
+                path: ['orchestration', 'orchestratorId'],
+            });
+        }
+        if (value.orchestration.excluded.includes(orchestratorId)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `orchestratorId '${orchestratorId}' cannot be excluded`,
+                path: ['orchestration', 'orchestratorId'],
+            });
+        }
     }),
     rules: z.object({
         scales: z.record(z.string(), z.object({
@@ -81,6 +113,11 @@ export const zigrixConfigSchema = z.object({
         workerPrompt: templateSchema,
         finalReport: templateSchema,
     }),
+    openclaw: z.object({
+        home: z.string().default(''),
+        binPath: z.string().nullable().default(null),
+        gatewayUrl: z.string().default(''),
+    }).default({ home: '', binPath: null, gatewayUrl: '' }),
     runtime: z.object({
         outputMode: z.enum(['text', 'json']),
         jsonIndent: z.number().int().min(0).max(8),
@@ -90,7 +127,7 @@ export const zigrixConfigJsonSchema = {
     $schema: 'https://json-schema.org/draft/2020-12/schema',
     title: 'ZigrixConfig',
     type: 'object',
-    required: ['paths', 'workspace', 'agents', 'rules', 'templates', 'runtime'],
+    required: ['paths', 'workspace', 'agents', 'rules', 'templates', 'openclaw', 'runtime'],
     properties: {
         paths: {
             type: 'object',
@@ -117,6 +154,15 @@ export const zigrixConfigJsonSchema = {
         agents: { type: 'object' },
         rules: { type: 'object' },
         templates: { type: 'object' },
+        openclaw: {
+            type: 'object',
+            properties: {
+                home: { type: 'string' },
+                binPath: { type: ['string', 'null'] },
+                gatewayUrl: { type: 'string' },
+            },
+            additionalProperties: false,
+        },
         runtime: { type: 'object' },
     },
     additionalProperties: false,

package/dist/configure.d.ts

@@ -11,6 +11,7 @@ export interface ConfigureResult {
     rulesSkipped: string[];
     skillsResult: SkillRegistrationResult | null;
     pathResult: PathStabilizeResult | null;
+    openclawPathResult: PathStabilizeResult | null;
     workspaceChanged: boolean;
     warnings: string[];
 }
@@ -19,6 +20,7 @@ export interface RunConfigureOptions {
     yes?: boolean;
     projectDir?: string;
     projectsBaseDir?: string;
+    orchestratorId?: string;
     silent?: boolean;
 }
 export declare function runConfigure(options: RunConfigureOptions): Promise<ConfigureResult>;

package/dist/configure.js

@@ -1,9 +1,8 @@
 import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
 import { removeAgent } from './agents/registry.js';
+import { resolveAbsolutePath } from './config/defaults.js';
 import { loadConfig, writeConfigFile } from './config/load.js';
-import { detectOpenClawHome, ensureZigrixInPath, filterAgents, loadOpenClawConfig, promptAgentSelection, registerAgents, registerSkills, seedRules, } from './onboard.js';
+import { detectOpenClawHome, ensureOpenClawInPath, ensureZigrixInPath, filterAgents, loadOpenClawConfig, promptAgentSelection, ensureOrchestratorId, registerAgents, registerSkills, resolveRuleSeedSource, seedRules, } from './onboard.js';
 import { resolvePaths } from './state/paths.js';
 const ALL_SECTIONS = ['agents', 'rules', 'workspace', 'path', 'skills'];
 // ─── Configure ────────────────────────────────────────────────────────────────
@@ -12,11 +11,7 @@ export async function runConfigure(options) {
     const silent = options.silent ?? false;
     const log = (msg) => { if (!silent)
         console.log(msg); };
-    // Resolve base dir at runtime (not from the static ZIGRIX_HOME constant)
-    const runtimeBaseDir = process.env.ZIGRIX_HOME
-        ? path.resolve(process.env.ZIGRIX_HOME)
-        : path.join(os.homedir(), '.zigrix');
-    const loaded = loadConfig({ baseDir: runtimeBaseDir });
+    const loaded = loadConfig();
     if (!loaded.configPath || !fs.existsSync(loaded.configPath)) {
         throw new Error('zigrix not initialized. Run `zigrix onboard` first.');
     }
@@ -33,6 +28,7 @@ export async function runConfigure(options) {
     let rulesSkipped = [];
     let skillsResult = null;
     let pathResult = null;
+    let openclawPathResult = null;
     let workspaceChanged = false;
     let configDirty = false;
     // ─── agents ───────────────────────────────────────────────────────────
@@ -81,9 +77,22 @@ export async function runConfigure(options) {
             log(`⚠️  ${warnings[warnings.length - 1]}`);
         }
     }
+    // ─── orchestrator ────────────────────────────────────────────────────
+    if (sections.includes('agents') || options.orchestratorId) {
+        const orchResult = ensureOrchestratorId(config, options.orchestratorId);
+        config = orchResult.config;
+        if (orchResult.changed) {
+            configDirty = true;
+            log(`✅ Orchestrator set to: ${config.agents.orchestration.orchestratorId}`);
+        }
+        if (orchResult.warning) {
+            warnings.push(orchResult.warning);
+            log(`⚠️  ${orchResult.warning}`);
+        }
+    }
     // ─── workspace ────────────────────────────────────────────────────────
     if (sections.includes('workspace') && options.projectsBaseDir) {
-        const resolved = path.resolve(options.projectsBaseDir);
+        const resolved = resolveAbsolutePath(options.projectsBaseDir);
         if (config.workspace.projectsBaseDir !== resolved) {
             config.workspace.projectsBaseDir = resolved;
             configDirty = true;
@@ -93,10 +102,12 @@ export async function runConfigure(options) {
     }
     // ─── rules ────────────────────────────────────────────────────────────
     if (sections.includes('rules')) {
-        const projectDir = options.projectDir ?? process.cwd();
-        const rulesSourceDir = path.join(projectDir, 'orchestration', 'rules');
-        if (fs.existsSync(rulesSourceDir)) {
-            const result = seedRules(rulesSourceDir, paths.rulesDir);
+        const ruleSeed = resolveRuleSeedSource(options.projectDir);
+        if (ruleSeed.sourceDir) {
+            if (options.projectDir && ruleSeed.source === 'bundled') {
+                log(`ℹ️  No external rule templates found under ${options.projectDir}; using bundled defaults.`);
+            }
+            const result = seedRules(ruleSeed.sourceDir, paths.rulesDir);
             rulesCopied = result.copied;
             rulesSkipped = result.skipped;
             if (rulesCopied.length > 0)
@@ -105,7 +116,7 @@ export async function runConfigure(options) {
                 log(`⏭️  Rules unchanged: ${rulesSkipped.join(', ')}`);
         }
         else {
-            log(`ℹ️  No orchestration/rules/ at ${projectDir} — rule seeding skipped.`);
+            log('ℹ️  No bundled rule templates available — rule seeding skipped.');
         }
     }
     // ─── path ─────────────────────────────────────────────────────────────
@@ -121,6 +132,17 @@ export async function runConfigure(options) {
             warnings.push(pathResult.warning);
             log(`⚠️  ${pathResult.warning}`);
         }
+        openclawPathResult = ensureOpenClawInPath();
+        if (openclawPathResult.symlinkCreated) {
+            log(`✅ openclaw symlinked to ${openclawPathResult.symlinkPath}`);
+        }
+        else if (openclawPathResult.alreadyInPath) {
+            log('✅ openclaw already in PATH');
+        }
+        if (openclawPathResult.warning) {
+            warnings.push(openclawPathResult.warning);
+            log(`⚠️  ${openclawPathResult.warning}`);
+        }
     }
     // ─── skills ───────────────────────────────────────────────────────────
     if (sections.includes('skills')) {
@@ -158,6 +180,7 @@ export async function runConfigure(options) {
         rulesSkipped,
         skillsResult,
         pathResult,
+        openclawPathResult,
         workspaceChanged,
         warnings,
     };

package/dist/dashboard/.next/BUILD_ID

@@ -1 +1 @@
-2a4glWei05xr4Jg0Ly6cp
+PT4hYxzrqxj-Zq4ZjtKNg