dexto 1.6.14 → 1.6.15

package/dist/cli/commands/deploy/entry-agent.d.ts

@@ -1,3 +1,3 @@
 export declare function isAgentYamlPath(filePath: string): boolean;
-export declare function discoverPrimaryWorkspaceAgent(workspaceRoot: string): string | null;
+export declare function discoverPrimaryWorkspaceAgent(workspaceRoot: string): Promise<string | null>;
 //# sourceMappingURL=entry-agent.d.ts.map

package/dist/cli/commands/deploy/entry-agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entry-agent.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/deploy/entry-agent.ts"],"names":[],"mappings":"AAWA,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED,wBAAgB,6BAA6B,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAWlF"}
+{"version":3,"file":"entry-agent.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/deploy/entry-agent.ts"],"names":[],"mappings":"AAiFA,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED,wBAAsB,6BAA6B,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAuBjG"}

package/dist/cli/commands/deploy/entry-agent.js

@@ -1,4 +1,5 @@
-import { existsSync } from 'fs';
+import { findProjectRegistryPath, getDefaultProjectRegistryEntry, readProjectRegistry, } from '@dexto/agent-management';
+import { existsSync, promises as fs } from 'fs';
 import path from 'path';
 import { normalizeWorkspaceRelativePath } from './config.js';
 const PRIMARY_WORKSPACE_AGENT_PATHS = [
@@ -7,15 +8,62 @@ const PRIMARY_WORKSPACE_AGENT_PATHS = [
     path.join('agents', 'coding-agent.yml'),
     path.join('agents', 'coding-agent.yaml'),
 ];
+async function loadWorkspaceProjectRegistry(workspaceRoot) {
+    const registryPath = await findProjectRegistryPath(workspaceRoot);
+    if (!registryPath) {
+        return null;
+    }
+    const registry = await readProjectRegistry(registryPath);
+    const defaultEntry = getDefaultProjectRegistryEntry(registry, registryPath);
+    if (!defaultEntry) {
+        return null;
+    }
+    return {
+        registryPath,
+        defaultConfigPath: await resolveWorkspaceRegistryConfigPath(workspaceRoot, registryPath, defaultEntry.configPath, defaultEntry.id),
+    };
+}
+async function resolveWorkspaceRegistryConfigPath(workspaceRoot, registryPath, configPath, agentId) {
+    const normalizedPath = normalizeWorkspaceRelativePath(configPath);
+    const absolutePath = path.resolve(path.dirname(registryPath), normalizedPath);
+    const relativeToWorkspace = path.relative(workspaceRoot, absolutePath);
+    if (relativeToWorkspace.startsWith('..') ||
+        path.isAbsolute(relativeToWorkspace) ||
+        relativeToWorkspace === '') {
+        throw new Error(`Agent '${agentId}' in ${registryPath} has invalid configPath '${configPath}': path must stay inside the workspace root.`);
+    }
+    let stat;
+    try {
+        stat = await fs.stat(absolutePath);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(`Agent '${agentId}' in ${registryPath} has invalid configPath '${configPath}': file does not exist.`);
+        }
+        throw error;
+    }
+    if (!stat.isFile()) {
+        throw new Error(`Agent '${agentId}' in ${registryPath} has invalid configPath '${configPath}': path must point to a file.`);
+    }
+    return absolutePath;
+}
 export function isAgentYamlPath(filePath) {
     return /\.(ya?ml)$/i.test(filePath);
 }
-export function discoverPrimaryWorkspaceAgent(workspaceRoot) {
+export async function discoverPrimaryWorkspaceAgent(workspaceRoot) {
+    const loadedRegistry = await loadWorkspaceProjectRegistry(workspaceRoot);
+    if (loadedRegistry) {
+        return normalizeWorkspaceRelativePath(path.relative(workspaceRoot, loadedRegistry.defaultConfigPath).replace(/\\/g, '/'));
+    }
     for (const relativePath of PRIMARY_WORKSPACE_AGENT_PATHS) {
         const absolutePath = path.join(workspaceRoot, relativePath);
         if (!existsSync(absolutePath)) {
             continue;
         }
+        const stat = await fs.stat(absolutePath);
+        if (!stat.isFile()) {
+            continue;
+        }
         return normalizeWorkspaceRelativePath(relativePath);
     }
     return null;

package/dist/cli/commands/deploy/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/deploy/index.ts"],"names":[],"mappings":"AA2BA,UAAU,kBAAkB;IACxB,WAAW,CAAC,EAAE,OAAO,CAAC;CACzB;AAwGD,wBAAsB,mBAAmB,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2ErF;AAED,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,IAAI,CAAC,CAiD7D;AAED,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,IAAI,CAAC,CAqB7D;AAED,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,IAAI,CAAC,CAkB/D;AAED,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,IAAI,CAAC,CA4B7D;AAED,wBAAsB,yBAAyB,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2C3F"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/deploy/index.ts"],"names":[],"mappings":"AA4BA,UAAU,kBAAkB;IACxB,WAAW,CAAC,EAAE,OAAO,CAAC;CACzB;AAyHD,wBAAsB,mBAAmB,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CA8ErF;AAED,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,IAAI,CAAC,CAiD7D;AAED,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,IAAI,CAAC,CAqB7D;AAED,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,IAAI,CAAC,CAkB/D;AAED,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,IAAI,CAAC,CA4B7D;AAED,wBAAsB,yBAAyB,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2C3F"}

package/dist/cli/commands/deploy/index.js

@@ -1,10 +1,11 @@
 import { existsSync } from 'fs';
 import path from 'path';
 import * as p from '@clack/prompts';
-import { findDextoProjectRoot } from '@dexto/agent-management';
+import { findDextoProjectRoot, loadAgentConfig } from '@dexto/agent-management';
 import chalk from 'chalk';
 import open from 'open';
 import { confirmOrExit } from '../../utils/prompt-helpers.js';
+import { validateAgentConfig } from '../../utils/config-validation.js';
 import { createCloudDefaultDeployConfig, createWorkspaceDeployConfig, getDeployConfigPath, isWorkspaceDeployAgent, loadDeployConfig, resolveWorkspaceDeployAgentPath, saveDeployConfig, } from './config.js';
 import { createDeployClient } from './client.js';
 import { discoverPrimaryWorkspaceAgent, isAgentYamlPath } from './entry-agent.js';
@@ -86,12 +87,25 @@ function ensureWorkspaceAgentExists(workspaceRoot, config) {
     }
     return entryAgentPath;
 }
+async function validateWorkspaceAgent(entryAgentPath, workspaceAgentPath) {
+    const config = await loadAgentConfig(entryAgentPath);
+    const validation = await validateAgentConfig(config, false, {
+        agentPath: workspaceAgentPath,
+        credentialPolicy: 'error',
+    });
+    if (!validation.success) {
+        throw new Error(`Workspace agent validation failed for ${workspaceAgentPath}. Fix the issues above before deploying.`);
+    }
+}
 export async function handleDeployCommand(options) {
     void options;
     p.intro(chalk.inverse('Deploy Workspace'));
     const workspaceRoot = resolveWorkspaceRoot();
     const deployConfig = await resolveDeployConfig(workspaceRoot);
-    ensureWorkspaceAgentExists(workspaceRoot, deployConfig);
+    const entryAgentPath = ensureWorkspaceAgentExists(workspaceRoot, deployConfig);
+    if (entryAgentPath && isWorkspaceDeployAgent(deployConfig.agent)) {
+        await validateWorkspaceAgent(entryAgentPath, deployConfig.agent.path);
+    }
     const deployLink = await loadWorkspaceDeployLink(workspaceRoot);
     const spinner = p.spinner();
     const client = createDeployClient();

package/dist/cli/commands/index.d.ts

@@ -1,5 +1,6 @@
 export { createDextoProject, type CreateAppOptions } from './create-app.js';
 export { createImage } from './create-image.js';
+export { handleInitCommand, handleInitAgentCommand, handleInitPrimaryCommand, handleInitSkillCommand, } from './init.js';
 export { getUserInputToInitDextoApp, initDexto, postInitDexto } from './init-app.js';
 export { handleSetupCommand, type CLISetupOptions, type CLISetupOptionsInput } from './setup.js';
 export { handleInstallCommand, type InstallCommandOptions } from './agents/install.js';

package/dist/cli/commands/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAAE,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAE5E,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EAAE,0BAA0B,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAErF,OAAO,EAAE,kBAAkB,EAAE,KAAK,eAAe,EAAE,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACjG,OAAO,EAAE,oBAAoB,EAAE,KAAK,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AACvF,OAAO,EAAE,sBAAsB,EAAE,KAAK,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAC7F,OAAO,EAAE,oBAAoB,EAAE,KAAK,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAChF,OAAO,EAAE,yBAAyB,EAAE,KAAK,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AAC5F,OAAO,EACH,uBAAuB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,6BAA6B,GACrC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,kBAAkB,EAAE,KAAK,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAC1E,OAAO,EACH,uBAAuB,EACvB,mBAAmB,EACnB,KAAK,wBAAwB,GAChC,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACH,yBAAyB,EACzB,sBAAsB,EACtB,qBAAqB,EACrB,wBAAwB,EACxB,wBAAwB,EACxB,KAAK,0BAA0B,EAC/B,KAAK,+BAA+B,GACvC,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAG/F,OAAO,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAGhE,OAAO,EACH,uBAAuB,EACvB,0BAA0B,EAC1B,4BAA4B,EAC5B,2BAA2B,EAE3B,2BAA2B,EAC3B,8BAA8B,EAC9B,8BAA8B,EAC9B,4BAA4B,EAC5B,+BAA+B,EAC/B,+BAA+B,EAC/B,KAAK,wBAAwB,EAC7B,KAAK,6BAA6B,EAClC,KAAK,2BAA2B,EAChC,KAAK,gCAAgC,EACrC,KAAK,6BAA6B,EAClC,KAAK,kCAAkC,EACvC,KAAK,4BAA4B,EACjC,KAAK,iCAAiC,EAEtC,KAAK,iCAAiC,EACtC,KAAK,oCAAoC,EACzC,KAAK,oCAAoC,EACzC,KAAK,kCAAkC,EACvC,KAAK,qCAAqC,GAC7C,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAAE,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAE5E,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EACH,iBAAiB,EACjB,sBAAsB,EACtB,wBAAwB,EACxB,sBAAsB,GACzB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,0BAA0B,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAErF,OAAO,EAAE,kBAAkB,EAAE,KAAK,eAAe,EAAE,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACjG,OAAO,EAAE,oBAAoB,EAAE,KAAK,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AACvF,OAAO,EAAE,sBAAsB,EAAE,KAAK,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAC7F,OAAO,EAAE,oBAAoB,EAAE,KAAK,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAChF,OAAO,EAAE,yBAAyB,EAAE,KAAK,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AAC5F,OAAO,EACH,uBAAuB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,6BAA6B,GACrC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,kBAAkB,EAAE,KAAK,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAC1E,OAAO,EACH,uBAAuB,EACvB,mBAAmB,EACnB,KAAK,wBAAwB,GAChC,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACH,yBAAyB,EACzB,sBAAsB,EACtB,qBAAqB,EACrB,wBAAwB,EACxB,wBAAwB,EACxB,KAAK,0BAA0B,EAC/B,KAAK,+BAA+B,GACvC,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAG/F,OAAO,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAGhE,OAAO,EACH,uBAAuB,EACvB,0BAA0B,EAC1B,4BAA4B,EAC5B,2BAA2B,EAE3B,2BAA2B,EAC3B,8BAA8B,EAC9B,8BAA8B,EAC9B,4BAA4B,EAC5B,+BAA+B,EAC/B,+BAA+B,EAC/B,KAAK,wBAAwB,EAC7B,KAAK,6BAA6B,EAClC,KAAK,2BAA2B,EAChC,KAAK,gCAAgC,EACrC,KAAK,6BAA6B,EAClC,KAAK,kCAAkC,EACvC,KAAK,4BAA4B,EACjC,KAAK,iCAAiC,EAEtC,KAAK,iCAAiC,EACtC,KAAK,oCAAoC,EACzC,KAAK,oCAAoC,EACzC,KAAK,kCAAkC,EACvC,KAAK,qCAAqC,GAC7C,MAAM,aAAa,CAAC"}

package/dist/cli/commands/index.js

@@ -2,6 +2,7 @@
 // Project setup commands
 export { createDextoProject } from './create-app.js';
 export { createImage } from './create-image.js';
+export { handleInitCommand, handleInitAgentCommand, handleInitPrimaryCommand, handleInitSkillCommand, } from './init.js';
 export { getUserInputToInitDextoApp, initDexto, postInitDexto } from './init-app.js';
 export { handleSetupCommand } from './setup.js';
 export { handleInstallCommand } from './agents/install.js';

package/dist/cli/commands/init.d.ts

@@ -0,0 +1,96 @@
+import type { Command } from 'commander';
+type ScaffoldEntryStatus = 'created' | 'existing';
+type RegistryUpdateStatus = 'created' | 'existing' | 'updated';
+export interface WorkspaceScaffoldResult {
+    root: string;
+    agentsFile: {
+        path: string;
+        status: ScaffoldEntryStatus;
+    };
+    directories: Array<{
+        path: string;
+        status: ScaffoldEntryStatus;
+    }>;
+}
+export interface WorkspaceAgentScaffoldResult {
+    workspace: WorkspaceScaffoldResult;
+    registry: {
+        path: string;
+        status: RegistryUpdateStatus;
+    };
+    agentConfig: {
+        path: string;
+        status: ScaffoldEntryStatus;
+    };
+    primaryAgent: {
+        id: string | null;
+        status: 'set' | 'unchanged';
+    };
+}
+export interface WorkspaceSkillScaffoldResult {
+    workspace: WorkspaceScaffoldResult;
+    skillFile: {
+        path: string;
+        status: ScaffoldEntryStatus;
+    };
+}
+export interface WorkspacePrimaryAgentResult {
+    workspace: WorkspaceScaffoldResult;
+    registry: {
+        path: string;
+        status: Exclude<RegistryUpdateStatus, 'created'>;
+    };
+    primaryAgent: {
+        id: string;
+        status: 'set' | 'existing';
+    };
+}
+export interface WorkspaceSubagentLinkResult {
+    workspace: WorkspaceScaffoldResult;
+    registry: {
+        path: string;
+        status: 'updated' | 'existing';
+    };
+    subagentId: string;
+    parentAgentId: string | null;
+    status: 'set' | 'existing' | 'no-primary';
+}
+export interface WorkspaceStatusResult {
+    workspaceRoot: string;
+    agentsFilePresent: boolean;
+    agentsDirectoryPresent: boolean;
+    skillsDirectoryPresent: boolean;
+    registryPath: string | null;
+    primaryAgentId: string | null;
+    allowGlobalAgents: boolean | null;
+    agents: Array<{
+        id: string;
+        isPrimary: boolean;
+        isSubagent: boolean;
+        parentAgentId: string | null;
+    }>;
+    skills: string[];
+    deployConfigPath: string | null;
+    effectiveDeploySummary: string;
+}
+export interface InitCommandRegisterContext {
+    program: Command;
+}
+type InitAgentCommandOptions = {
+    subagent?: boolean;
+    primary?: boolean;
+};
+export declare function createWorkspaceScaffold(workspaceRoot?: string): Promise<WorkspaceScaffoldResult>;
+export declare function createWorkspaceAgentScaffold(agentIdInput: string, options?: InitAgentCommandOptions, workspaceRoot?: string): Promise<WorkspaceAgentScaffoldResult>;
+export declare function createWorkspaceSkillScaffold(skillIdInput: string, workspaceRoot?: string): Promise<WorkspaceSkillScaffoldResult>;
+export declare function setWorkspacePrimaryAgent(agentIdInput: string, workspaceRoot?: string): Promise<WorkspacePrimaryAgentResult>;
+export declare function linkWorkspaceSubagentToPrimaryAgent(subagentIdInput: string, workspaceRoot?: string): Promise<WorkspaceSubagentLinkResult>;
+export declare function inspectWorkspaceStatus(workspaceRoot?: string): Promise<WorkspaceStatusResult>;
+export declare function handleInitCommand(workspaceRoot?: string): Promise<void>;
+export declare function handleInitAgentCommand(agentIdInput: string | undefined, options?: InitAgentCommandOptions, workspaceRoot?: string): Promise<void>;
+export declare function handleInitSkillCommand(skillId: string, workspaceRoot?: string): Promise<void>;
+export declare function handleInitPrimaryCommand(agentIdInput: string | undefined, workspaceRoot?: string): Promise<void>;
+export declare function handleInitStatusCommand(workspaceRoot?: string): Promise<void>;
+export declare function registerInitCommand({ program }: InitCommandRegisterContext): void;
+export {};
+//# sourceMappingURL=init.d.ts.map

package/dist/cli/commands/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/init.ts"],"names":[],"mappings":"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"}

package/dist/cli/commands/init.js

@@ -0,0 +1,834 @@
+import * as p from '@clack/prompts';
+import { deriveDisplayName, findProjectRegistryPath as findSharedProjectRegistryPath, getPrimaryApiKeyEnvVar, getProjectRegistryPath as getCanonicalProjectRegistryPath, ProjectRegistrySchema, readProjectRegistry as readSharedProjectRegistry, writeConfigFile, } from '@dexto/agent-management';
+import chalk from 'chalk';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { ExitSignal, safeExit, withAnalytics } from '../../analytics/wrapper.js';
+import { getDeployConfigPath, isWorkspaceDeployAgent, loadDeployConfig } from './deploy/config.js';
+import { discoverPrimaryWorkspaceAgent } from './deploy/entry-agent.js';
+import { selectOrExit, textOrExit } from '../utils/prompt-helpers.js';
+const AGENTS_FILENAME = 'AGENTS.md';
+const WORKSPACE_DIRECTORIES = ['agents', 'skills'];
+const DEFAULT_AGENT_PROVIDER = 'openai';
+const DEFAULT_AGENT_MODEL = 'gpt-5.3-codex';
+const DEFAULT_AGENT_VERSION = '0.1.0';
+const DEFAULT_AGENTS_MD = `<!-- dexto-workspace -->
+
+# Dexto Workspace
+
+This workspace can define project-specific agents and skills.
+
+## Structure
+- Put custom agents and subagents in \`agents/\`
+- Put custom skills in \`skills/<skill-id>/SKILL.md\`
+- Use \`.dexto/\` only for Dexto-managed state and installed assets
+
+## Defaults
+- If no workspace agent is defined, Dexto uses your global default agent locally
+- Cloud deploys without a workspace agent use the managed cloud default agent
+`;
+const ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function isSubagentEntry(entry) {
+    return (entry.tags?.includes('subagent') ?? false) || Boolean(entry.parentAgentId);
+}
+function isPrimaryCandidate(entry) {
+    return !isSubagentEntry(entry);
+}
+function getEffectiveWorkspacePrimaryAgentId(registry) {
+    if (registry.primaryAgent) {
+        return registry.primaryAgent;
+    }
+    const candidates = registry.agents.filter(isPrimaryCandidate);
+    if (candidates.length === 1) {
+        return candidates[0]?.id ?? null;
+    }
+    return null;
+}
+function getWorkspaceAgentEntry(registry, agentId) {
+    return registry.agents.find((entry) => entry.id === agentId) ?? null;
+}
+async function ensureWorkspaceRoot(root) {
+    const stat = await fs.stat(root);
+    if (!stat.isDirectory()) {
+        throw new Error(`${root} exists and is not a directory`);
+    }
+}
+async function getExistingEntryType(entryPath) {
+    try {
+        const stat = await fs.stat(entryPath);
+        if (stat.isDirectory()) {
+            return 'directory';
+        }
+        if (stat.isFile()) {
+            return 'file';
+        }
+        return 'file';
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return 'missing';
+        }
+        throw error;
+    }
+}
+function normalizeScaffoldId(id, kind) {
+    const normalized = id.trim();
+    if (!ID_PATTERN.test(normalized)) {
+        throw new Error(`Invalid ${kind} id '${id}'. Use kebab-case like '${kind === 'agent' ? 'coding-agent' : 'code-review'}'.`);
+    }
+    return normalized;
+}
+async function ensureDirectory(dirPath) {
+    try {
+        const stat = await fs.stat(dirPath);
+        if (!stat.isDirectory()) {
+            throw new Error(`${dirPath} exists and is not a directory`);
+        }
+        return 'existing';
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    await fs.mkdir(dirPath, { recursive: true });
+    return 'created';
+}
+async function ensureFile(filePath, content) {
+    try {
+        const stat = await fs.stat(filePath);
+        if (!stat.isFile()) {
+            throw new Error(`${filePath} exists and is not a file`);
+        }
+        return 'existing';
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    await fs.writeFile(filePath, content, 'utf-8');
+    return 'created';
+}
+async function loadInitialAgentLlmConfig() {
+    return {
+        provider: DEFAULT_AGENT_PROVIDER,
+        model: DEFAULT_AGENT_MODEL,
+        apiKey: `$${getPrimaryApiKeyEnvVar(DEFAULT_AGENT_PROVIDER)}`,
+    };
+}
+function buildAgentDescription(agentId, options) {
+    if (options.subagent) {
+        return `Workspace sub-agent '${agentId}' for delegated tasks.`;
+    }
+    if (agentId === 'coding-agent') {
+        return 'Primary workspace agent for this project.';
+    }
+    return `Workspace agent '${agentId}' for this project.`;
+}
+async function buildAgentConfig(agentId, options) {
+    const llmConfig = await loadInitialAgentLlmConfig();
+    const displayName = deriveDisplayName(agentId);
+    const description = buildAgentDescription(agentId, options);
+    const llm = {
+        provider: llmConfig.provider,
+        model: llmConfig.model,
+        apiKey: llmConfig.apiKey,
+    };
+    return {
+        image: '@dexto/image-local',
+        agentId,
+        agentCard: {
+            name: displayName,
+            description,
+            url: `https://example.com/agents/${agentId}`,
+            version: DEFAULT_AGENT_VERSION,
+        },
+        systemPrompt: options.subagent
+            ? [
+                `You are ${displayName}, a specialized sub-agent for this workspace.`,
+                '',
+                'Complete delegated tasks efficiently and concisely.',
+                'Read the relevant files before responding.',
+                'Return a clear result to the parent agent with concrete findings or next steps.',
+            ].join('\n')
+            : [
+                `You are ${displayName}, the workspace agent for this project.`,
+                '',
+                'Help the user understand, edit, run, and deploy the files in this workspace.',
+                'Read relevant files before making changes.',
+                'Keep changes focused and explain what changed.',
+            ].join('\n'),
+        greeting: options.subagent
+            ? `Ready to help as ${displayName}.`
+            : 'Ready to work in this workspace.',
+        llm,
+        permissions: {
+            mode: 'manual',
+            allowedToolsStorage: 'storage',
+        },
+    };
+}
+function buildRegistryEntry(agentId, options) {
+    const description = buildAgentDescription(agentId, options);
+    return {
+        id: agentId,
+        name: deriveDisplayName(agentId),
+        description,
+        configPath: `./${agentId}/${agentId}.yml`,
+        ...(options.subagent ? { tags: ['subagent'] } : {}),
+    };
+}
+function addSubagentTag(entry) {
+    const tags = new Set(entry.tags ?? []);
+    tags.add('subagent');
+    return {
+        ...entry,
+        tags: Array.from(tags).sort(),
+    };
+}
+function validateInitAgentOptions(options) {
+    if (options.primary && options.subagent) {
+        throw new Error('A sub-agent cannot also be the primary workspace agent.');
+    }
+}
+async function promptForAgentId(kind) {
+    const placeholder = kind === 'subagent'
+        ? 'explore-agent'
+        : kind === 'primary'
+            ? 'review-agent'
+            : 'helper-agent';
+    return await textOrExit({
+        message: 'Agent id',
+        placeholder,
+        validate(value) {
+            try {
+                normalizeScaffoldId(value, 'agent');
+                return undefined;
+            }
+            catch (error) {
+                return error instanceof Error ? error.message : 'Invalid agent id';
+            }
+        },
+    }, 'Agent initialization cancelled');
+}
+async function resolveInitAgentInput(agentIdInput, options, workspaceRoot) {
+    validateInitAgentOptions(options);
+    if (agentIdInput) {
+        return {
+            agentId: normalizeScaffoldId(agentIdInput, 'agent'),
+            options,
+        };
+    }
+    if (options.subagent || options.primary) {
+        const kind = options.subagent ? 'subagent' : 'primary';
+        return {
+            agentId: normalizeScaffoldId(await promptForAgentId(kind), 'agent'),
+            options,
+        };
+    }
+    const registryState = await loadWorkspaceProjectRegistry(path.resolve(workspaceRoot));
+    const currentPrimaryAgentId = getEffectiveWorkspacePrimaryAgentId(registryState.registry);
+    const kind = await selectOrExit({
+        message: 'What kind of agent do you want to create?',
+        initialValue: currentPrimaryAgentId ? 'agent' : 'primary',
+        options: [
+            {
+                value: 'primary',
+                label: 'Primary agent',
+                hint: currentPrimaryAgentId
+                    ? `Replace current primary (${currentPrimaryAgentId})`
+                    : 'Main workspace agent used by default',
+            },
+            {
+                value: 'agent',
+                label: 'Additional agent',
+                hint: 'Workspace agent that is available but not the default',
+            },
+            {
+                value: 'subagent',
+                label: 'Subagent',
+                hint: 'Delegated helper agent for the primary workspace agent',
+            },
+        ],
+    }, 'Agent initialization cancelled');
+    const resolvedOptions = kind === 'primary' ? { primary: true } : kind === 'subagent' ? { subagent: true } : {};
+    return {
+        agentId: normalizeScaffoldId(await promptForAgentId(kind), 'agent'),
+        options: resolvedOptions,
+    };
+}
+function buildSkillTemplate(skillId) {
+    const displayName = deriveDisplayName(skillId);
+    return `---
+name: "${skillId}"
+description: "TODO: Describe when to use this skill."
+---
+
+# ${displayName}
+
+## Purpose
+Describe what this skill helps the agent accomplish.
+
+## Inputs
+- The task or context that should trigger this skill
+- Relevant files, paths, or constraints
+
+## Steps
+1. Review the relevant context.
+2. Apply the workflow for this skill.
+3. Return a concise result with any important follow-up actions.
+
+## Output Format
+- Summary of what was found or changed
+- Key decisions or recommendations
+- Follow-up actions, if any
+`;
+}
+async function loadWorkspaceProjectRegistry(workspaceRoot) {
+    const existingPath = await findSharedProjectRegistryPath(workspaceRoot);
+    if (!existingPath) {
+        return {
+            path: getCanonicalProjectRegistryPath(workspaceRoot),
+            registry: { allowGlobalAgents: false, agents: [] },
+            status: 'created',
+        };
+    }
+    return {
+        path: existingPath,
+        registry: await readSharedProjectRegistry(existingPath),
+        status: 'existing',
+    };
+}
+async function saveWorkspaceProjectRegistry(registryPath, registry) {
+    await fs.mkdir(path.dirname(registryPath), { recursive: true });
+    const validatedRegistry = ProjectRegistrySchema.parse(registry);
+    await fs.writeFile(registryPath, `${JSON.stringify(validatedRegistry, null, 2)}\n`, 'utf8');
+}
+export async function createWorkspaceScaffold(workspaceRoot = process.cwd()) {
+    const root = path.resolve(workspaceRoot);
+    const agentsFilePath = path.join(root, AGENTS_FILENAME);
+    await ensureWorkspaceRoot(root);
+    const agentsFileType = await getExistingEntryType(agentsFilePath);
+    if (agentsFileType === 'directory') {
+        throw new Error(`${agentsFilePath} exists and is not a file`);
+    }
+    for (const directory of WORKSPACE_DIRECTORIES) {
+        const dirPath = path.join(root, directory);
+        const entryType = await getExistingEntryType(dirPath);
+        if (entryType === 'file') {
+            throw new Error(`${dirPath} exists and is not a directory`);
+        }
+    }
+    const agentsFileStatus = await ensureFile(agentsFilePath, DEFAULT_AGENTS_MD);
+    const directories = [];
+    for (const directory of WORKSPACE_DIRECTORIES) {
+        const dirPath = path.join(root, directory);
+        const status = await ensureDirectory(dirPath);
+        directories.push({ path: dirPath, status });
+    }
+    return {
+        root,
+        agentsFile: { path: agentsFilePath, status: agentsFileStatus },
+        directories,
+    };
+}
+export async function createWorkspaceAgentScaffold(agentIdInput, options = {}, workspaceRoot = process.cwd()) {
+    validateInitAgentOptions(options);
+    const agentId = normalizeScaffoldId(agentIdInput, 'agent');
+    const workspace = await createWorkspaceScaffold(workspaceRoot);
+    const agentDirPath = path.join(workspace.root, 'agents', agentId);
+    const agentConfigPath = path.join(agentDirPath, `${agentId}.yml`);
+    const registryState = await loadWorkspaceProjectRegistry(workspace.root);
+    const existingEntry = registryState.registry.agents.find((entry) => entry.id === agentId);
+    const expectedRegistryEntry = buildRegistryEntry(agentId, options);
+    const currentPrimaryAgentId = getEffectiveWorkspacePrimaryAgentId(registryState.registry);
+    if (existingEntry && existingEntry.configPath !== expectedRegistryEntry.configPath) {
+        throw new Error(`Agent '${agentId}' already exists in ${registryState.path} with configPath '${existingEntry.configPath}'.`);
+    }
+    await ensureDirectory(agentDirPath);
+    let agentConfigStatus;
+    const agentConfigEntryType = await getExistingEntryType(agentConfigPath);
+    if (agentConfigEntryType === 'directory') {
+        throw new Error(`${agentConfigPath} exists and is not a file`);
+    }
+    if (agentConfigEntryType === 'file') {
+        agentConfigStatus = 'existing';
+    }
+    else {
+        const config = await buildAgentConfig(agentId, options);
+        await writeConfigFile(agentConfigPath, config);
+        agentConfigStatus = 'created';
+    }
+    if (existingEntry) {
+        let registryUpdated = false;
+        if (options.subagent && !isSubagentEntry(existingEntry)) {
+            if (currentPrimaryAgentId === agentId) {
+                throw new Error(`Agent '${agentId}' is currently the workspace primary agent. Set another primary agent before converting it to a subagent.`);
+            }
+            registryState.registry.agents = registryState.registry.agents.map((entry) => entry.id === agentId ? addSubagentTag(entry) : entry);
+            registryUpdated = true;
+        }
+        let primaryAgentStatus = 'unchanged';
+        if (options.primary && registryState.registry.primaryAgent !== agentId) {
+            const updatedEntry = getWorkspaceAgentEntry(registryState.registry, agentId);
+            if (!updatedEntry || !isPrimaryCandidate(updatedEntry)) {
+                throw new Error(`Agent '${agentId}' is marked as a subagent and cannot be selected as the workspace primary agent.`);
+            }
+            registryState.registry.primaryAgent = agentId;
+            primaryAgentStatus = 'set';
+            registryUpdated = true;
+        }
+        if (registryUpdated) {
+            await saveWorkspaceProjectRegistry(registryState.path, registryState.registry);
+        }
+        return {
+            workspace,
+            registry: {
+                path: registryState.path,
+                status: registryUpdated ? 'updated' : registryState.status,
+            },
+            agentConfig: { path: agentConfigPath, status: agentConfigStatus },
+            primaryAgent: {
+                id: getEffectiveWorkspacePrimaryAgentId(registryState.registry),
+                status: primaryAgentStatus,
+            },
+        };
+    }
+    registryState.registry.agents.push(expectedRegistryEntry);
+    registryState.registry.agents.sort((left, right) => left.id.localeCompare(right.id));
+    const primaryCandidatesAfterAdd = registryState.registry.agents.filter(isPrimaryCandidate);
+    let primaryAgentStatus = 'unchanged';
+    if (!options.subagent &&
+        (options.primary || (!currentPrimaryAgentId && primaryCandidatesAfterAdd.length === 1)) &&
+        registryState.registry.primaryAgent !== agentId) {
+        registryState.registry.primaryAgent = agentId;
+        primaryAgentStatus = 'set';
+    }
+    await saveWorkspaceProjectRegistry(registryState.path, registryState.registry);
+    return {
+        workspace,
+        registry: {
+            path: registryState.path,
+            status: registryState.status === 'created' ? 'created' : 'updated',
+        },
+        agentConfig: { path: agentConfigPath, status: agentConfigStatus },
+        primaryAgent: {
+            id: getEffectiveWorkspacePrimaryAgentId(registryState.registry),
+            status: primaryAgentStatus,
+        },
+    };
+}
+export async function createWorkspaceSkillScaffold(skillIdInput, workspaceRoot = process.cwd()) {
+    const skillId = normalizeScaffoldId(skillIdInput, 'skill');
+    const workspace = await createWorkspaceScaffold(workspaceRoot);
+    const skillDirPath = path.join(workspace.root, 'skills', skillId);
+    const skillFilePath = path.join(skillDirPath, 'SKILL.md');
+    await ensureDirectory(skillDirPath);
+    const skillFileStatus = await ensureFile(skillFilePath, buildSkillTemplate(skillId));
+    return {
+        workspace,
+        skillFile: {
+            path: skillFilePath,
+            status: skillFileStatus,
+        },
+    };
+}
+export async function setWorkspacePrimaryAgent(agentIdInput, workspaceRoot = process.cwd()) {
+    const agentId = normalizeScaffoldId(agentIdInput, 'agent');
+    const workspace = await createWorkspaceScaffold(workspaceRoot);
+    const registryState = await loadWorkspaceProjectRegistry(workspace.root);
+    const existingEntry = registryState.registry.agents.find((entry) => entry.id === agentId);
+    if (!existingEntry) {
+        throw new Error(`Agent '${agentId}' is not registered in ${path.relative(workspace.root, registryState.path)}. Run \`dexto init agent ${agentId}\` first or update the registry manually.`);
+    }
+    if (!isPrimaryCandidate(existingEntry)) {
+        throw new Error(`Agent '${agentId}' is marked as a subagent and cannot be selected as the workspace primary agent.`);
+    }
+    if (registryState.registry.primaryAgent === agentId) {
+        return {
+            workspace,
+            registry: { path: registryState.path, status: 'existing' },
+            primaryAgent: { id: agentId, status: 'existing' },
+        };
+    }
+    registryState.registry.primaryAgent = agentId;
+    await saveWorkspaceProjectRegistry(registryState.path, registryState.registry);
+    return {
+        workspace,
+        registry: { path: registryState.path, status: 'updated' },
+        primaryAgent: { id: agentId, status: 'set' },
+    };
+}
+export async function linkWorkspaceSubagentToPrimaryAgent(subagentIdInput, workspaceRoot = process.cwd()) {
+    const subagentId = normalizeScaffoldId(subagentIdInput, 'agent');
+    const workspace = await createWorkspaceScaffold(workspaceRoot);
+    const registryState = await loadWorkspaceProjectRegistry(workspace.root);
+    const subagentEntry = getWorkspaceAgentEntry(registryState.registry, subagentId);
+    if (!subagentEntry) {
+        throw new Error(`Agent '${subagentId}' is not registered in ${path.relative(workspace.root, registryState.path)}.`);
+    }
+    const primaryAgentId = getEffectiveWorkspacePrimaryAgentId(registryState.registry);
+    if (!primaryAgentId || primaryAgentId === subagentId) {
+        return {
+            workspace,
+            registry: { path: registryState.path, status: 'existing' },
+            subagentId,
+            parentAgentId: primaryAgentId,
+            status: 'no-primary',
+        };
+    }
+    const needsSubagentTag = !isSubagentEntry(subagentEntry);
+    if (subagentEntry.parentAgentId === primaryAgentId && !needsSubagentTag) {
+        return {
+            workspace,
+            registry: { path: registryState.path, status: 'existing' },
+            subagentId,
+            parentAgentId: primaryAgentId,
+            status: 'existing',
+        };
+    }
+    registryState.registry.agents = registryState.registry.agents.map((entry) => entry.id === subagentId
+        ? { ...addSubagentTag(entry), parentAgentId: primaryAgentId }
+        : entry);
+    await saveWorkspaceProjectRegistry(registryState.path, registryState.registry);
+    return {
+        workspace,
+        registry: { path: registryState.path, status: 'updated' },
+        subagentId,
+        parentAgentId: primaryAgentId,
+        status: 'set',
+    };
+}
+function formatCreatedPaths(result) {
+    const createdPaths = [];
+    if (result.agentsFile.status === 'created') {
+        createdPaths.push(path.relative(result.root, result.agentsFile.path) || AGENTS_FILENAME);
+    }
+    for (const directory of result.directories) {
+        if (directory.status === 'created') {
+            createdPaths.push(path.relative(result.root, directory.path) || path.basename(directory.path));
+        }
+    }
+    return createdPaths;
+}
+function formatAgentPaths(result) {
+    const createdPaths = formatCreatedPaths(result.workspace);
+    if (result.registry.status === 'created' || result.registry.status === 'updated') {
+        createdPaths.push(path.relative(result.workspace.root, result.registry.path));
+    }
+    if (result.agentConfig.status === 'created') {
+        createdPaths.push(path.relative(result.workspace.root, result.agentConfig.path));
+    }
+    return createdPaths;
+}
+function formatSkillPaths(result) {
+    const createdPaths = formatCreatedPaths(result.workspace);
+    if (result.skillFile.status === 'created') {
+        createdPaths.push(path.relative(result.workspace.root, result.skillFile.path));
+    }
+    return createdPaths;
+}
+async function listWorkspaceSkillIds(workspaceRoot) {
+    const skillsRoot = path.join(workspaceRoot, 'skills');
+    try {
+        const entries = await fs.readdir(skillsRoot, { withFileTypes: true });
+        const skillIds = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const skillFilePath = path.join(skillsRoot, entry.name, 'SKILL.md');
+            try {
+                const stat = await fs.stat(skillFilePath);
+                if (stat.isFile()) {
+                    skillIds.push(entry.name);
+                }
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return skillIds.sort((left, right) => left.localeCompare(right));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+}
+function describeEffectiveDeployAgent(input) {
+    if (input.deployConfig) {
+        const configuredAgent = isWorkspaceDeployAgent(input.deployConfig.agent)
+            ? `workspace agent (${input.deployConfig.agent.path})`
+            : 'default cloud agent';
+        return `${configuredAgent} via ${input.deployConfigPath ?? '.dexto/deploy.json'}`;
+    }
+    if (input.implicitWorkspaceAgent) {
+        return `workspace agent (${input.implicitWorkspaceAgent}) if you run \`dexto deploy\``;
+    }
+    return 'default cloud agent if you run `dexto deploy`';
+}
+export async function inspectWorkspaceStatus(workspaceRoot = process.cwd()) {
+    const root = path.resolve(workspaceRoot);
+    await ensureWorkspaceRoot(root);
+    const agentsFilePresent = (await getExistingEntryType(path.join(root, AGENTS_FILENAME))) === 'file';
+    const agentsDirectoryPresent = (await getExistingEntryType(path.join(root, 'agents'))) === 'directory';
+    const skillsDirectoryPresent = (await getExistingEntryType(path.join(root, 'skills'))) === 'directory';
+    const registryPath = await findSharedProjectRegistryPath(root);
+    const registry = registryPath ? await readSharedProjectRegistry(registryPath) : null;
+    const primaryAgentId = registry ? getEffectiveWorkspacePrimaryAgentId(registry) : null;
+    const agents = registry?.agents
+        .map((entry) => ({
+        id: entry.id,
+        isPrimary: primaryAgentId === entry.id,
+        isSubagent: isSubagentEntry(entry),
+        parentAgentId: entry.parentAgentId ?? null,
+    }))
+        .sort((left, right) => left.id.localeCompare(right.id)) ?? [];
+    const skills = await listWorkspaceSkillIds(root);
+    const deployConfigPath = getDeployConfigPath(root);
+    const deployConfig = await loadDeployConfig(root);
+    const implicitWorkspaceAgent = await discoverPrimaryWorkspaceAgent(root);
+    return {
+        workspaceRoot: root,
+        agentsFilePresent,
+        agentsDirectoryPresent,
+        skillsDirectoryPresent,
+        registryPath,
+        primaryAgentId,
+        allowGlobalAgents: registry ? registry.allowGlobalAgents : null,
+        agents,
+        skills,
+        deployConfigPath: deployConfig ? deployConfigPath : null,
+        effectiveDeploySummary: describeEffectiveDeployAgent({
+            deployConfigPath: deployConfig ? deployConfigPath : null,
+            deployConfig,
+            implicitWorkspaceAgent,
+        }),
+    };
+}
+function formatWorkspaceStatus(result) {
+    return [
+        `Workspace: ${result.workspaceRoot}`,
+        `AGENTS.md: ${result.agentsFilePresent ? 'present' : 'missing'}`,
+        `agents/: ${result.agentsDirectoryPresent ? 'present' : 'missing'}`,
+        `skills/: ${result.skillsDirectoryPresent ? 'present' : 'missing'}`,
+        `Registry: ${result.registryPath ? path.relative(result.workspaceRoot, result.registryPath) : 'none'}`,
+        `Primary agent: ${result.primaryAgentId ?? 'none (global default used locally)'}`,
+        `Allow global agents: ${result.allowGlobalAgents === null
+            ? 'n/a (no workspace registry)'
+            : String(result.allowGlobalAgents)}`,
+        `Deploy: ${result.effectiveDeploySummary}`,
+        '',
+        'Agents:',
+        ...(result.agents.length > 0
+            ? result.agents.map((agent) => {
+                const details = [
+                    agent.isPrimary ? 'primary' : null,
+                    agent.isSubagent ? 'subagent' : null,
+                    agent.parentAgentId ? `parent: ${agent.parentAgentId}` : null,
+                ].filter(Boolean);
+                return `- ${agent.id}${details.length > 0 ? ` (${details.join(', ')})` : ''}`;
+            })
+            : ['- none']),
+        '',
+        'Skills:',
+        ...(result.skills.length > 0 ? result.skills.map((skillId) => `- ${skillId}`) : ['- none']),
+    ].join('\n');
+}
+async function resolvePrimaryAgentSelection(agentIdInput, workspaceRoot) {
+    if (agentIdInput) {
+        return normalizeScaffoldId(agentIdInput, 'agent');
+    }
+    const workspace = await createWorkspaceScaffold(workspaceRoot);
+    const registryState = await loadWorkspaceProjectRegistry(workspace.root);
+    const primaryCandidates = registryState.registry.agents.filter(isPrimaryCandidate);
+    if (primaryCandidates.length === 0) {
+        throw new Error('No primary-capable workspace agents found. Run `dexto init agent` first.');
+    }
+    if (primaryCandidates.length === 1) {
+        return primaryCandidates[0]?.id ?? '';
+    }
+    const currentPrimaryAgentId = getEffectiveWorkspacePrimaryAgentId(registryState.registry);
+    const initialValue = primaryCandidates.some((entry) => entry.id === currentPrimaryAgentId)
+        ? currentPrimaryAgentId
+        : undefined;
+    return await selectOrExit({
+        message: 'Which agent should be the workspace primary?',
+        initialValue,
+        options: primaryCandidates.map((entry) => ({
+            value: entry.id,
+            label: `${entry.name} (${entry.id})`,
+            hint: registryState.registry.primaryAgent === entry.id
+                ? 'Current primary'
+                : entry.description,
+        })),
+    }, 'Primary agent selection cancelled');
+}
+export async function handleInitCommand(workspaceRoot = process.cwd()) {
+    p.intro(chalk.inverse('Dexto Init'));
+    const result = await createWorkspaceScaffold(workspaceRoot);
+    const createdPaths = formatCreatedPaths(result);
+    if (createdPaths.length === 0) {
+        p.outro(chalk.green('Workspace already initialized.'));
+        return;
+    }
+    p.note(createdPaths.map((item) => `- ${item}`).join('\n'), 'Created');
+    p.outro(chalk.green('Workspace initialized.'));
+}
+export async function handleInitAgentCommand(agentIdInput, options = {}, workspaceRoot = process.cwd()) {
+    p.intro(chalk.inverse('Dexto Init Agent'));
+    const resolved = await resolveInitAgentInput(agentIdInput, options, workspaceRoot);
+    const result = await createWorkspaceAgentScaffold(resolved.agentId, resolved.options, workspaceRoot);
+    const subagentLinkResult = resolved.options.subagent
+        ? await linkWorkspaceSubagentToPrimaryAgent(resolved.agentId, workspaceRoot)
+        : null;
+    const createdPaths = formatAgentPaths(result);
+    if (createdPaths.length === 0) {
+        p.outro(chalk.green([
+            `Agent '${resolved.agentId}' already initialized.`,
+            ...(subagentLinkResult?.status === 'set' && subagentLinkResult.parentAgentId
+                ? [`Linked to primary agent: ${subagentLinkResult.parentAgentId}`]
+                : subagentLinkResult?.status === 'no-primary'
+                    ? ['No primary agent found to link this subagent.']
+                    : []),
+        ].join('\n')));
+        return;
+    }
+    p.note(createdPaths.map((item) => `- ${item}`).join('\n'), 'Created');
+    p.outro(chalk.green([
+        resolved.options.subagent
+            ? `Sub-agent '${resolved.agentId}' initialized.`
+            : `Agent '${resolved.agentId}' initialized.`,
+        ...(result.primaryAgent.status === 'set' && result.primaryAgent.id
+            ? [`Primary agent: ${result.primaryAgent.id}`]
+            : []),
+        ...(subagentLinkResult?.status === 'set' && subagentLinkResult.parentAgentId
+            ? [`Linked to primary agent: ${subagentLinkResult.parentAgentId}`]
+            : subagentLinkResult?.status === 'no-primary'
+                ? [
+                    'No primary agent found to link this subagent. Use `dexto init primary <id>` and rerun if needed.',
+                ]
+                : []),
+    ].join('\n')));
+}
+export async function handleInitSkillCommand(skillId, workspaceRoot = process.cwd()) {
+    p.intro(chalk.inverse('Dexto Init Skill'));
+    const result = await createWorkspaceSkillScaffold(skillId, workspaceRoot);
+    const createdPaths = formatSkillPaths(result);
+    if (createdPaths.length === 0) {
+        p.outro(chalk.green(`Skill '${skillId}' already initialized.`));
+        return;
+    }
+    p.note(createdPaths.map((item) => `- ${item}`).join('\n'), 'Created');
+    p.outro(chalk.green(`Skill '${skillId}' initialized.`));
+}
+export async function handleInitPrimaryCommand(agentIdInput, workspaceRoot = process.cwd()) {
+    p.intro(chalk.inverse('Dexto Init Primary'));
+    const agentId = await resolvePrimaryAgentSelection(agentIdInput, workspaceRoot);
+    const result = await setWorkspacePrimaryAgent(agentId, workspaceRoot);
+    if (result.primaryAgent.status === 'existing') {
+        p.outro(chalk.green(`'${agentId}' is already the workspace primary agent.`));
+        return;
+    }
+    p.note(path.relative(result.workspace.root, result.registry.path), 'Updated');
+    p.outro(chalk.green(`Primary agent set to '${agentId}'.`));
+}
+export async function handleInitStatusCommand(workspaceRoot = process.cwd()) {
+    p.intro(chalk.inverse('Dexto Init Status'));
+    const result = await inspectWorkspaceStatus(workspaceRoot);
+    p.outro(formatWorkspaceStatus(result));
+}
+export function registerInitCommand({ program }) {
+    const initCommand = program
+        .command('init')
+        .description('Initialize the current folder as a Dexto workspace');
+    initCommand.addHelpText('after', `
+Examples:
+  $ dexto init
+  $ dexto init agent
+  $ dexto init agent explore-agent --subagent
+  $ dexto init primary review-agent
+  $ dexto init skill code-review
+  $ dexto init status
+`);
+    initCommand.action(withAnalytics('init', async () => {
+        try {
+            await handleInitCommand();
+            safeExit('init', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto init command failed: ${err}`);
+            safeExit('init', 1, 'error');
+        }
+    }));
+    initCommand
+        .command('agent [id]')
+        .description('Create a workspace agent scaffold')
+        .option('--subagent', 'Create a specialized sub-agent scaffold')
+        .option('--primary', 'Set this agent as the workspace primary')
+        .action(withAnalytics('init agent', async (id, options) => {
+        try {
+            await handleInitAgentCommand(id, options);
+            safeExit('init agent', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto init agent command failed: ${err}`);
+            safeExit('init agent', 1, 'error');
+        }
+    }));
+    initCommand
+        .command('primary [id]')
+        .description('Set the workspace primary agent')
+        .action(withAnalytics('init primary', async (id) => {
+        try {
+            await handleInitPrimaryCommand(id);
+            safeExit('init primary', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto init primary command failed: ${err}`);
+            safeExit('init primary', 1, 'error');
+        }
+    }));
+    initCommand
+        .command('skill <id>')
+        .description('Create a workspace skill scaffold')
+        .action(withAnalytics('init skill', async (id) => {
+        try {
+            await handleInitSkillCommand(id);
+            safeExit('init skill', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto init skill command failed: ${err}`);
+            safeExit('init skill', 1, 'error');
+        }
+    }));
+    initCommand
+        .command('status')
+        .description('Show the current workspace configuration and deploy preview')
+        .action(withAnalytics('init status', async () => {
+        try {
+            await handleInitStatusCommand();
+            safeExit('init status', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto init status command failed: ${err}`);
+            safeExit('init status', 1, 'error');
+        }
+    }));
+}

package/dist/index-main.js

@@ -45,7 +45,7 @@ const cliVersion = resolveCliVersion();
 process.env.DEXTO_CLI_VERSION = cliVersion;
 import { logger, getProviderFromModel, getAllSupportedModels, startLlmRegistryAutoUpdate, DextoAgent, isPath, resolveApiKeyForProvider, getPrimaryApiKeyEnvVar, } from '@dexto/core';
 import { applyImageDefaults, cleanNullValues, AgentConfigSchema, loadImage, resolveServicesFromConfig, setImageImporter, toDextoAgentOptions, } from '@dexto/agent-config';
-import { getDextoPackageRoot, resolveAgentPath, loadAgentConfig, globalPreferencesExist, loadGlobalPreferences, resolveBundledScript, enrichAgentConfig, isDextoAuthEnabled, } from '@dexto/agent-management';
+import { getDextoPackageRoot, resolveAgentPath, loadAgentConfig, findDextoProjectRoot, globalPreferencesExist, loadGlobalPreferences, resolveBundledScript, enrichAgentConfig, isDextoAuthEnabled, } from '@dexto/agent-management';
 import { validateCliOptions, handleCliOptionsError } from './cli/utils/options.js';
 import { validateAgentConfig } from './cli/utils/config-validation.js';
 import { applyCLIOverrides, applyUserPreferences } from './config/cli-overrides.js';
@@ -59,6 +59,7 @@ import { registerImageCommand } from './cli/commands/image/register.js';
 import { registerPluginCommand } from './cli/commands/plugin/register.js';
 import { registerAgentsCommand } from './cli/commands/agents/register.js';
 import { registerDeployCommand } from './cli/commands/deploy/register.js';
+import { registerInitCommand } from './cli/commands/init.js';
 const program = new Command();
 let imageImporterConfigured = false;
 let dextoApiKeyBootstrapped = false;
@@ -148,6 +149,7 @@ program
 }));
 registerImageCommand({ program });
 registerDeployCommand({ program });
+registerInitCommand({ program });
 // 4) `init-app` SUB-COMMAND
 program
     .command('init-app')
@@ -294,6 +296,7 @@ async function bootstrapAgentFromGlobalOpts(options) {
         inferredApiKey = apiKey;
     }
     const resolvedPath = await resolveAgentPath(globalOpts.agent, globalOpts.autoInstall !== false);
+    const workspaceRoot = findDextoProjectRoot(process.cwd()) ?? process.cwd();
     const rawConfig = await loadAgentConfig(resolvedPath);
     const mergedConfig = applyCLIOverrides(rawConfig, {
         ...globalOpts,
@@ -330,6 +333,7 @@ async function bootstrapAgentFromGlobalOpts(options) {
         // Headless run keeps output deterministic and noise-free.
         // Other non-interactive commands keep visible logs.
         logLevel: isHeadlessRun ? 'error' : 'info',
+        workspaceRoot,
     });
     if (isHeadlessRun) {
         // Force silent transport in headless mode even when agent config defines logger settings.
@@ -699,9 +703,11 @@ program
         // Enrichment adds filesystem paths to storage (schema has in-memory defaults)
         // Interactive CLI mode: only log to file (console would interfere with chat UI)
         const isInteractiveCli = opts.mode === 'cli';
+        const workspaceRoot = findDextoProjectRoot(process.cwd()) ?? process.cwd();
         const enrichedConfig = enrichAgentConfig(configWithImageDefaults, resolvedPath, {
             isInteractiveCli,
             logLevel: 'info', // CLI uses info-level logging for visibility
+            workspaceRoot,
         });
         // Validate enriched config + preflight credentials.
         // - Interactive modes (web/cli): warn and continue when credentials are missing

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dexto",
-  "version": "1.6.14",
+  "version": "1.6.15",
   "type": "module",
   "bin": {
     "dexto": "./dist/index.js"
@@ -34,16 +34,16 @@
     "ws": "^8.18.1",
     "yaml": "^2.7.1",
     "zod": "^3.25.0",
-    "@dexto/agent-config": "1.6.14",
-    "@dexto/agent-management": "1.6.14",
-    "@dexto/analytics": "1.6.14",
-    "@dexto/core": "1.6.14",
-    "@dexto/image-local": "1.6.14",
-    "@dexto/image-logger-agent": "1.6.14",
-    "@dexto/registry": "1.6.14",
-    "@dexto/server": "1.6.14",
-    "@dexto/storage": "1.6.14",
-    "@dexto/tui": "1.6.14"
+    "@dexto/agent-config": "1.6.15",
+    "@dexto/agent-management": "1.6.15",
+    "@dexto/analytics": "1.6.15",
+    "@dexto/core": "1.6.15",
+    "@dexto/image-local": "1.6.15",
+    "@dexto/image-logger-agent": "1.6.15",
+    "@dexto/registry": "1.6.15",
+    "@dexto/server": "1.6.15",
+    "@dexto/storage": "1.6.15",
+    "@dexto/tui": "1.6.15"
   },
   "devDependencies": {
     "@types/ws": "^8.5.11",